Bug 1117003 - Backout cset ca3c73188295 (Bug 1115903, Part 2), r=ehsan
authorBrian Smith <brian@briansmith.org>
Fri, 02 Jan 2015 12:26:14 -0800
changeset 222019 6b9c81a8c08149be5c3499b47b3e4230ee36fc24
parent 222018 5c86509a11bc8868f0967c451c216b8d0ce2e1c2
child 222020 d8bdb31fcf9c3446526529784f22ebb2a43d4a29
push id53493
push usercbook@mozilla.com
push dateMon, 05 Jan 2015 14:49:50 +0000
treeherdermozilla-inbound@d8bdb31fcf9c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersehsan
bugs1117003, 1115903
milestone37.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1117003 - Backout cset ca3c73188295 (Bug 1115903, Part 2), r=ehsan
security/pkix/include/pkix/Input.h
security/pkix/include/pkix/ScopedPtr.h
security/pkix/include/pkix/bind.h
security/pkix/include/pkix/pkixtypes.h
security/pkix/lib/pkixbuild.cpp
security/pkix/lib/pkixocsp.cpp
security/pkix/lib/pkixutil.h
security/pkix/test/gtest/pkixocsp_VerifyEncodedOCSPResponse.cpp
security/pkix/test/lib/pkixtestutil.h
--- a/security/pkix/include/pkix/Input.h
+++ b/security/pkix/include/pkix/Input.h
@@ -119,17 +119,17 @@ public:
   // Don't use this. It is here because we have some "friend" functions that we
   // don't want to declare in this header file.
   const uint8_t* UnsafeGetData() const { return data; }
 
 private:
   const uint8_t* data;
   size_t len;
 
-  void operator=(const Input&) = delete; // Use Init instead.
+  void operator=(const Input&) /* = delete */; // Use Init instead.
 };
 
 inline bool
 InputsAreEqual(const Input& a, const Input& b)
 {
   return a.GetLength() == b.GetLength() &&
          !std::memcmp(a.UnsafeGetData(), b.UnsafeGetData(), a.GetLength());
 }
@@ -286,17 +286,17 @@ public:
 
   class Mark
   {
   private:
     friend class Reader;
     Mark(const Reader& input, const uint8_t* mark) : input(input), mark(mark) { }
     const Reader& input;
     const uint8_t* const mark;
-    void operator=(const Mark&) = delete;
+    void operator=(const Mark&) /* = delete */;
   };
 
   Mark GetMark() const { return Mark(*this, input); }
 
   Result GetInput(const Mark& mark, /*out*/ Input& item)
   {
     if (&mark.input != this || mark.mark > input) {
       return NotReached("invalid mark", Result::FATAL_ERROR_INVALID_ARGS);
@@ -315,18 +315,18 @@ private:
     input = data;
     end = data + len;
     return Success;
   }
 
   const uint8_t* input;
   const uint8_t* end;
 
-  Reader(const Reader&) = delete;
-  void operator=(const Reader&) = delete;
+  Reader(const Reader&) /* = delete */;
+  void operator=(const Reader&) /* = delete */;
 };
 
 inline bool
 InputContains(const Input& input, uint8_t toFind)
 {
   Reader reader(input);
   for (;;) {
     uint8_t b;
--- a/security/pkix/include/pkix/ScopedPtr.h
+++ b/security/pkix/include/pkix/ScopedPtr.h
@@ -64,18 +64,18 @@ public:
     return result;
   }
 
   void reset() { *this = nullptr; }
 
 protected:
   T* mValue;
 
-  ScopedPtr(const ScopedPtr&) = delete;
-  void operator=(const ScopedPtr&) = delete;
+  ScopedPtr(const ScopedPtr&) /* = delete */;
+  void operator=(const ScopedPtr&) /* = delete */;
 };
 
 template <typename T, void(&Destroyer)(T*)>
 inline bool
 operator==(T* a, const ScopedPtr<T, Destroyer>& b)
 {
   return a == b.get();
 }
--- a/security/pkix/include/pkix/bind.h
+++ b/security/pkix/include/pkix/bind.h
@@ -75,47 +75,47 @@ class Bind1
 {
 public:
   typedef R (&F)(P1&, B1&);
   Bind1(F f, B1& b1) : f(f), b1(b1) { }
   R operator()(P1& p1) const { return f(p1, b1); }
 private:
   F f;
   B1& b1;
-  void operator=(const Bind1&) = delete;
+  void operator=(const Bind1&) /*= delete*/;
 };
 
 template <typename R, typename P1, typename B1, typename B2>
 class Bind2
 {
 public:
   typedef R (&F)(P1&, B1&, B2&);
   Bind2(F f, B1& b1, B2& b2) : f(f), b1(b1), b2(b2) { }
   R operator()(P1& p1) const { return f(p1, b1, b2); }
 private:
   F f;
   B1& b1;
   B2& b2;
-  void operator=(const Bind2&) = delete;
+  void operator=(const Bind2&) /*= delete*/;
 };
 
 template <typename R, typename P1, typename B1, typename B2, typename B3>
 class Bind3
 {
 public:
   typedef R (&F)(P1&, B1, B2, B3&);
   Bind3(F f, B1& b1, B2& b2, B3& b3)
     : f(f), b1(b1), b2(b2), b3(b3) { }
   R operator()(P1& p1) const { return f(p1, b1, b2, b3); }
 private:
   F f;
   B1& b1;
   B2& b2;
   B3& b3;
-  void operator=(const Bind3&) = delete;
+  void operator=(const Bind3&) /*= delete*/;
 };
 
 template <typename R, typename P1, typename B1, typename B2, typename B3,
           typename B4>
 class Bind4
 {
 public:
   typedef R (&F)(P1&, B1, B2, B3&, B4&);
@@ -123,17 +123,17 @@ public:
     : f(f), b1(b1), b2(b2), b3(b3), b4(b4) { }
   R operator()(P1& p1) const { return f(p1, b1, b2, b3, b4); }
 private:
   F f;
   B1& b1;
   B2& b2;
   B3& b3;
   B4& b4;
-  void operator=(const Bind4&) = delete;
+  void operator=(const Bind4&) /*= delete*/;
 };
 
 template <typename R, typename C1, typename P1, typename P2, typename P3,
           typename P4>
 class BindToMemberFunction4
 {
 public:
   // XXX: C++ doesn't have reference-to-member function, only
@@ -143,17 +143,17 @@ public:
   BindToMemberFunction4(F f, C1& that) : f(f), that(that) { }
   R operator()(P1& p1, P2& p2, P3 p3, P4& p4) const
   {
     return (that.*f)(p1, p2, p3, p4);
   }
 private:
   const F f;
   C1& that;
-  void operator=(const BindToMemberFunction4&) = delete;
+  void operator=(const BindToMemberFunction4&) /*= delete*/;
 };
 
 template <typename R, typename P1, typename B1, typename B2, typename B3,
           typename B4, typename B5>
 class Bind5
 {
 public:
   typedef R (&F)(P1&, B1, B2, B3, B4, B5);
@@ -162,17 +162,17 @@ public:
   R operator()(P1& p1) const { return f(p1, b1, b2, b3, b4, b5); }
 private:
   F f;
   B1 b1;
   B2 b2;
   B3 b3;
   B4 b4;
   B5 b5;
-  void operator=(const Bind5&) = delete;
+  void operator=(const Bind5&) /*= delete*/;
 };
 
 } // namespace internal
 
 template <typename R, typename P1, typename B1>
 inline internal::Bind1<R, P1, B1>
 bind(R (&f)(P1&, B1&), Placeholder1&, B1& b1)
 {
--- a/security/pkix/include/pkix/pkixtypes.h
+++ b/security/pkix/include/pkix/pkixtypes.h
@@ -75,17 +75,18 @@ MOZILLA_PKIX_ENUM_CLASS SignatureAlgorit
 
 struct SignedDataWithSignature
 {
 public:
   Input data;
   SignatureAlgorithm algorithm;
   Input signature;
 
-  void operator=(const SignedDataWithSignature&) = delete;
+private:
+  void operator=(const SignedDataWithSignature&) /*= delete*/;
 };
 
 MOZILLA_PKIX_ENUM_CLASS EndEntityOrCA { MustBeEndEntity = 0, MustBeCA = 1 };
 
 MOZILLA_PKIX_ENUM_CLASS KeyUsage : uint8_t {
   digitalSignature = 0,
   nonRepudiation   = 1,
   keyEncipherment  = 2,
@@ -142,18 +143,18 @@ public:
     : issuer(issuer)
     , issuerSubjectPublicKeyInfo(issuerSubjectPublicKeyInfo)
     , serialNumber(serialNumber)
   {
   }
   const Input issuer;
   const Input issuerSubjectPublicKeyInfo;
   const Input serialNumber;
-
-  void operator=(const CertID&) = delete;
+private:
+  void operator=(const CertID&) /*= delete*/;
 };
 
 class DERArray
 {
 public:
   // Returns the number of DER-encoded items in the array.
   virtual size_t GetLength() const = 0;
 
@@ -203,19 +204,19 @@ public:
     // constraints will be checked in addition to any any name constraints
     // contained in potentialIssuerDER.
     virtual Result Check(Input potentialIssuerDER,
             /*optional*/ const Input* additionalNameConstraints,
                  /*out*/ bool& keepGoing) = 0;
   protected:
     IssuerChecker();
     virtual ~IssuerChecker();
-
-    IssuerChecker(const IssuerChecker&) = delete;
-    void operator=(const IssuerChecker&) = delete;
+  private:
+    IssuerChecker(const IssuerChecker&) /*= delete*/;
+    void operator=(const IssuerChecker&) /*= delete*/;
   };
 
   // Search for a CA certificate with the given name. The implementation must
   // call checker.Check with the DER encoding of the potential issuer
   // certificate. The implementation must follow these rules:
   //
   // * The implementation must be reentrant and must limit the amount of stack
   //   space it uses; see the note on reentrancy and stack usage below.
@@ -319,15 +320,16 @@ public:
   // other, extensive, memory safety efforts in mozilla::pkix, and we should
   // find a way to provide a more-obviously-safe interface.
   static const size_t DIGEST_LENGTH = 20; // length of SHA-1 digest
   virtual Result DigestBuf(Input item, /*out*/ uint8_t* digestBuf,
                            size_t digestBufLen) = 0;
 protected:
   TrustDomain() { }
 
-  TrustDomain(const TrustDomain&) = delete;
-  void operator=(const TrustDomain&) = delete;
+private:
+  TrustDomain(const TrustDomain&) /* = delete */;
+  void operator=(const TrustDomain&) /* = delete */;
 };
 
 } } // namespace mozilla::pkix
 
 #endif // mozilla_pkix__pkixtypes_h
--- a/security/pkix/lib/pkixbuild.cpp
+++ b/security/pkix/lib/pkixbuild.cpp
@@ -79,18 +79,18 @@ private:
   /*optional*/ Input const* const stapledOCSPResponse;
   const unsigned int subCACount;
   const Result deferredSubjectError;
 
   Result RecordResult(Result currentResult, /*out*/ bool& keepGoing);
   Result result;
   bool resultWasSet;
 
-  PathBuildingStep(const PathBuildingStep&) = delete;
-  void operator=(const PathBuildingStep&) = delete;
+  PathBuildingStep(const PathBuildingStep&) /*= delete*/;
+  void operator=(const PathBuildingStep&) /*= delete*/;
 };
 
 Result
 PathBuildingStep::RecordResult(Result newResult, /*out*/ bool& keepGoing)
 {
   if (newResult == Result::ERROR_UNTRUSTED_CERT) {
     newResult = Result::ERROR_UNTRUSTED_ISSUER;
   } else if (newResult == Result::ERROR_EXPIRED_CERTIFICATE) {
--- a/security/pkix/lib/pkixocsp.cpp
+++ b/security/pkix/lib/pkixocsp.cpp
@@ -66,18 +66,19 @@ public:
   const CertID& certID;
   const Time time;
   const uint16_t maxLifetimeInDays;
   CertStatus certStatus;
   Time* thisUpdate;
   Time* validThrough;
   bool expired;
 
-  Context(const Context&) = delete;
-  void operator=(const Context&) = delete;
+private:
+  Context(const Context&); // delete
+  void operator=(const Context&); // delete
 };
 
 // Verify that potentialSigner is a valid delegated OCSP response signing cert
 // according to RFC 6960 section 4.2.2.2.
 static Result
 CheckOCSPResponseSignerCert(TrustDomain& trustDomain,
                             BackCert& potentialSigner,
                             Input issuerSubject,
--- a/security/pkix/lib/pkixutil.h
+++ b/security/pkix/lib/pkixutil.h
@@ -138,18 +138,18 @@ private:
   Input keyUsage;
   Input nameConstraints;
   Input subjectAltName;
   Input criticalNetscapeCertificateType;
 
   Result RememberExtension(Reader& extnID, const Input& extnValue,
                            bool critical, /*out*/ bool& understood);
 
-  BackCert(const BackCert&) = delete;
-  void operator=(const BackCert&) = delete;
+  BackCert(const BackCert&) /* = delete */;
+  void operator=(const BackCert&); /* = delete */;
 };
 
 class NonOwningDERArray : public DERArray
 {
 public:
   NonOwningDERArray()
     : numItems(0)
   {
@@ -178,18 +178,18 @@ public:
   }
 
   // Public so we can static_assert on this. Keep in sync with MAX_SUBCA_COUNT.
   static const size_t MAX_LENGTH = 8;
 private:
   Input items[MAX_LENGTH]; // avoids any heap allocations
   size_t numItems;
 
-  NonOwningDERArray(const NonOwningDERArray&) = delete;
-  void operator=(const NonOwningDERArray&) = delete;
+  NonOwningDERArray(const NonOwningDERArray&) /* = delete*/;
+  void operator=(const NonOwningDERArray&) /* = delete*/;
 };
 
 inline unsigned int
 DaysBeforeYear(unsigned int year)
 {
   assert(year <= 9999);
   return ((year - 1u) * 365u)
        + ((year - 1u) / 4u)    // leap years are every 4 years,
--- a/security/pkix/test/gtest/pkixocsp_VerifyEncodedOCSPResponse.cpp
+++ b/security/pkix/test/gtest/pkixocsp_VerifyEncodedOCSPResponse.cpp
@@ -81,18 +81,19 @@ public:
     return TestDigestBuf(item, digestBuf, digestBufLen);
   }
 
   virtual Result CheckPublicKey(Input subjectPublicKeyInfo)
   {
     return TestCheckPublicKey(subjectPublicKeyInfo);
   }
 
-  OCSPTestTrustDomain(const OCSPTestTrustDomain&) = delete;
-  void operator=(const OCSPTestTrustDomain&) = delete;
+private:
+  OCSPTestTrustDomain(const OCSPTestTrustDomain&) /*delete*/;
+  void operator=(const OCSPTestTrustDomain&) /*delete*/;
 };
 
 namespace {
 char const* const rootName = "Test CA 1";
 void deleteCertID(CertID* certID) { delete certID; }
 } // unnamed namespace
 
 class pkixocsp_VerifyEncodedResponse : public ::testing::Test
--- a/security/pkix/test/lib/pkixtestutil.h
+++ b/security/pkix/test/lib/pkixtestutil.h
@@ -242,18 +242,18 @@ public:
   virtual TestKeyPair* Clone() const = 0;
 protected:
   TestKeyPair(const ByteString& spki, const ByteString& spk)
     : subjectPublicKeyInfo(spki)
     , subjectPublicKey(spk)
   {
   }
 
-  TestKeyPair(const TestKeyPair&) = delete;
-  void operator=(const TestKeyPair&) = delete;
+  TestKeyPair(const TestKeyPair&) /*= delete*/;
+  void operator=(const TestKeyPair&) /*= delete*/;
 };
 
 TestKeyPair* CloneReusedKeyPair();
 TestKeyPair* GenerateKeyPair();
 TestKeyPair* GenerateDSSKeyPair();
 inline void DeleteTestKeyPair(TestKeyPair* keyPair) { delete keyPair; }
 typedef ScopedPtr<TestKeyPair, DeleteTestKeyPair> ScopedTestKeyPair;