Remove dynamic exception specifications

...(for now, from LIBO_INTERNAL_CODE only).  See the mail thread starting at
<https://lists.freedesktop.org/archives/libreoffice/2017-January/076665.html>
"Dynamic Exception Specifications" for details.

Most changes have been done automatically by the rewriting loplugin:dynexcspec
(after enabling the rewriting mode, to be committed shortly).  The way it only
removes exception specs from declarations if it also sees a definition, it
identified some dead declarations-w/o-definitions (that have been removed
manually) and some cases where a definition appeared in multiple include files
(which have also been cleaned up manually).  There's also been cases of macro
paramters (that were used to abstract over exception specs) that have become
unused now (and been removed).

Furthermore, some code needed to be cleaned up manually
(avmedia/source/quicktime/ and connectivity/source/drivers/kab/), as I had no
configurations available that would actually build that code.  Missing @throws
documentation has not been applied in such manual clean-up.

Change-Id: I3408691256c9b0c12bc5332de976743626e13960
Reviewed-on: https://gerrit.libreoffice.org/33574
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>

1 files changed, 33 insertions, 88 deletions

diff --git a/vcl/qa/cppunit/canvasbitmaptest.cxx b/vcl/qa/cppunit/canvasbitmaptest.cxx
index 53ce5c91cbcd..ff3479cdce13 100644
--- a/vcl/qa/cppunit/canvasbitmaptest.cxx
+++ b/vcl/qa/cppunit/canvasbitmaptest.cxx
@@ -249,18 +249,14 @@ private:
     const sal_Int32                mnBitsPerPixel;
 
     // XBitmap
-    virtual geometry::IntegerSize2D SAL_CALL getSize() throw (uno::RuntimeException, std::exception) override { return maSize; }
-    virtual sal_Bool SAL_CALL hasAlpha(  ) throw (uno::RuntimeException, std::exception) override { return mnBitsPerPixel != 8; }
+    virtual geometry::IntegerSize2D SAL_CALL getSize() override { return maSize; }
+    virtual sal_Bool SAL_CALL hasAlpha(  ) override { return mnBitsPerPixel != 8; }
     virtual uno::Reference< rendering::XBitmap > SAL_CALL getScaledBitmap( const geometry::RealSize2D&,
-                                                                           sal_Bool ) throw (uno::RuntimeException, std::exception) override { return this; }
+                                                                           sal_Bool ) override { return this; }
 
     // XIntegerReadOnlyBitmap
     virtual uno::Sequence< ::sal_Int8 > SAL_CALL getData( rendering::IntegerBitmapLayout&     bitmapLayout,
-                                                          const geometry::IntegerRectangle2D& rect )
-        throw (lang::IndexOutOfBoundsException,
-               rendering::VolatileContentDestroyedException,
-               uno::RuntimeException,
-               std::exception) override
+                                                          const geometry::IntegerRectangle2D& rect ) override
     {
         CPPUNIT_ASSERT_MESSAGE( "X1 out of bounds", rect.X1 >= 0 );
         CPPUNIT_ASSERT_MESSAGE( "Y1 out of bounds", rect.Y1 >= 0 );
@@ -305,18 +301,14 @@ private:
     }
 
     virtual uno::Sequence< ::sal_Int8 > SAL_CALL getPixel( rendering::IntegerBitmapLayout&,
-                                                           const geometry::IntegerPoint2D&  )
-        throw (lang::IndexOutOfBoundsException,
-               rendering::VolatileContentDestroyedException,
-               uno::RuntimeException,
-               std::exception) override
+                                                           const geometry::IntegerPoint2D&  ) override
     {
         CPPUNIT_ASSERT_MESSAGE("getPixel: method not implemented", false);
         return uno::Sequence< sal_Int8 >();
     }
 
     /// @throws uno::RuntimeException
-    uno::Reference< rendering::XBitmapPalette > SAL_CALL getPalette(  ) throw (uno::RuntimeException)
+    uno::Reference< rendering::XBitmapPalette > SAL_CALL getPalette(  )
     {
         uno::Reference< XBitmapPalette > aRet;
         if( mnBitsPerPixel == 8 )
@@ -324,7 +316,7 @@ private:
         return aRet;
     }
 
-    virtual rendering::IntegerBitmapLayout SAL_CALL getMemoryLayout(  ) throw (uno::RuntimeException, std::exception) override
+    virtual rendering::IntegerBitmapLayout SAL_CALL getMemoryLayout(  ) override
     {
         rendering::IntegerBitmapLayout aLayout( maLayout );
 
@@ -340,7 +332,7 @@ private:
     }
 
     // XBitmapPalette
-    virtual sal_Int32 SAL_CALL getNumberOfEntries() throw (uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL getNumberOfEntries() override
     {
         CPPUNIT_ASSERT_MESSAGE( "Got palette getNumberOfEntries interface call without handing out palette",
                                 getPalette().is() );
@@ -349,10 +341,7 @@ private:
     }
 
     virtual sal_Bool SAL_CALL getIndex( uno::Sequence< double >& entry,
-                                          ::sal_Int32 nIndex )
-        throw (lang::IndexOutOfBoundsException,
-               uno::RuntimeException,
-               std::exception) override
+                                          ::sal_Int32 nIndex ) override
     {
         CPPUNIT_ASSERT_MESSAGE( "Got palette getIndex interface call without handing out palette",
                                 getPalette().is() );
@@ -368,10 +357,7 @@ private:
 
     virtual sal_Bool SAL_CALL setIndex( const uno::Sequence< double >&,
                                           sal_Bool,
-                                          ::sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException,
-                                                                      lang::IllegalArgumentException,
-                                                                      uno::RuntimeException,
-                                                                      std::exception) override
+                                          ::sal_Int32 nIndex ) override
     {
         CPPUNIT_ASSERT_MESSAGE( "Got palette setIndex interface call without handing out palette",
                                 getPalette().is());
@@ -389,7 +375,7 @@ private:
         }
     };
 
-    virtual uno::Reference< rendering::XColorSpace > SAL_CALL getColorSpace(  ) throw (uno::RuntimeException, std::exception) override
+    virtual uno::Reference< rendering::XColorSpace > SAL_CALL getColorSpace(  ) override
     {
         // this is the method from XBitmapPalette. Return palette color
         // space here
@@ -397,129 +383,100 @@ private:
     }
 
     // XIntegerBitmapColorSpace
-    virtual ::sal_Int8 SAL_CALL getType(  ) throw (uno::RuntimeException, std::exception) override
+    virtual ::sal_Int8 SAL_CALL getType(  ) override
     {
         return rendering::ColorSpaceType::RGB;
     }
 
-    virtual uno::Sequence< sal_Int8 > SAL_CALL getComponentTags(  ) throw (uno::RuntimeException, std::exception) override
+    virtual uno::Sequence< sal_Int8 > SAL_CALL getComponentTags(  ) override
     {
         return maComponentTags;
     }
 
-    virtual ::sal_Int8 SAL_CALL getRenderingIntent(  ) throw (uno::RuntimeException, std::exception) override
+    virtual ::sal_Int8 SAL_CALL getRenderingIntent(  ) override
     {
         return rendering::RenderingIntent::PERCEPTUAL;
     }
 
-    virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties()
-        throw (uno::RuntimeException,
-               std::exception) override
+    virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties() override
     {
         CPPUNIT_ASSERT_MESSAGE("getProperties: method not implemented", false );
         return uno::Sequence< ::beans::PropertyValue >();
     }
 
     virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >&,
-                                                                const uno::Reference< rendering::XColorSpace >& )
-        throw (uno::RuntimeException,
-               std::exception) override
+                                                                const uno::Reference< rendering::XColorSpace >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertColorSpace: method not implemented", false);
         return uno::Sequence< double >();
     }
 
-    virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& )
-        throw (lang::IllegalArgumentException,
-               uno::RuntimeException,
-               std::exception) override
+    virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertToRGB: method not implemented", false);
         return uno::Sequence< rendering::RGBColor >();
     }
 
-    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& )
-        throw (lang::IllegalArgumentException,
-               uno::RuntimeException,
-               std::exception) override
+    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertToARGB: method not implemented", false);
         return uno::Sequence< rendering::ARGBColor >();
     }
 
-    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& )
-        throw (lang::IllegalArgumentException,
-               uno::RuntimeException,
-               std::exception) override
+    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertToPARGB: method not implemented", false);
         return uno::Sequence< rendering::ARGBColor >();
     }
 
-    virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& )
-        throw (lang::IllegalArgumentException,
-               uno::RuntimeException,
-               std::exception) override
+    virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertFromRGB: method not implemented", false);
         return uno::Sequence< double >();
     }
 
-    virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& )
-        throw (lang::IllegalArgumentException,
-               uno::RuntimeException,
-               std::exception) override
+    virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertFromARGB: this method is not expected to be called!", false);
         return uno::Sequence< double >();
     }
 
-    virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& )
-        throw (lang::IllegalArgumentException,
-               uno::RuntimeException,
-               std::exception) override
+    virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertFromPARGB: this method is not expected to be called!", false);
         return uno::Sequence< double >();
     }
 
-    virtual ::sal_Int32 SAL_CALL getBitsPerPixel(  ) throw (uno::RuntimeException, std::exception) override
+    virtual ::sal_Int32 SAL_CALL getBitsPerPixel(  ) override
     {
         return mnBitsPerPixel;
     }
 
-    virtual uno::Sequence< ::sal_Int32 > SAL_CALL getComponentBitCounts(  ) throw (uno::RuntimeException, std::exception) override
+    virtual uno::Sequence< ::sal_Int32 > SAL_CALL getComponentBitCounts(  ) override
     {
         return maComponentBitCounts;
     }
 
-    virtual ::sal_Int8 SAL_CALL getEndianness(  ) throw (uno::RuntimeException, std::exception) override
+    virtual ::sal_Int8 SAL_CALL getEndianness(  ) override
     {
         return util::Endianness::LITTLE;
     }
 
     virtual uno::Sequence< double > SAL_CALL convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& ,
-                                                                           const uno::Reference< rendering::XColorSpace >& )
-        throw (lang::IllegalArgumentException,
-               uno::RuntimeException,
-               std::exception) override
+                                                                           const uno::Reference< rendering::XColorSpace >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertFromIntegerColorSpace: method not implemented", false);
         return uno::Sequence< double >();
     }
 
     virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& ,
-                                                                             const uno::Reference< rendering::XIntegerBitmapColorSpace >& )
-        throw (lang::IllegalArgumentException,
-               uno::RuntimeException,
-               std::exception) override
+                                                                             const uno::Reference< rendering::XIntegerBitmapColorSpace >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertToIntegerColorSpace: method not implemented", false);
         return uno::Sequence< sal_Int8 >();
     }
 
-    virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,
-                                                                                                                                       uno::RuntimeException, std::exception) override
+    virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) override
     {
         const uno::Sequence< rendering::ARGBColor > aTemp( convertIntegerToARGB(deviceColor) );
         const std::size_t nLen(aTemp.getLength());
@@ -535,8 +492,7 @@ private:
         return aRes;
     }
 
-    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,
-                                                                                                                                         uno::RuntimeException, std::exception) override
+    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) override
     {
         const std::size_t  nLen( deviceColor.getLength() );
         const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
@@ -573,10 +529,7 @@ private:
     }
 
     virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB(
-        const uno::Sequence< ::sal_Int8 >& deviceColor)
-            throw (lang::IllegalArgumentException,
-                   uno::RuntimeException,
-                   std::exception) override
+        const uno::Sequence< ::sal_Int8 >& deviceColor) override
     {
         const std::size_t  nLen( deviceColor.getLength() );
         const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
@@ -614,27 +567,19 @@ private:
     }
 
     virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB(
-        const uno::Sequence< rendering::RGBColor >&)
-            throw (lang::IllegalArgumentException,
-                   uno::RuntimeException,
-                   std::exception) override
+        const uno::Sequence< rendering::RGBColor >&) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertIntegerFromRGB: method not implemented", false);
         return uno::Sequence< sal_Int8 >();
     }
 
-    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException,
-                                                                                                                               uno::RuntimeException,
-                                  std::exception) override
+    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertIntegerFromARGB: method not implemented", false);
         return uno::Sequence< sal_Int8 >();
     }
 
-    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& )
-        throw (lang::IllegalArgumentException,
-        uno::RuntimeException,
-        std::exception) override
+    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& ) override
     {
         CPPUNIT_ASSERT_MESSAGE("convertIntegerFromPARGB: method not implemented", false);
         return uno::Sequence< sal_Int8 >();