Relanding: Removing #defines previously used for building without BoringSSL/OpenSSL.

webrtc/base/helpers.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/helpers.h"
 
 #include <limits>
 #include <memory>
 
-#if defined(FEATURE_ENABLE_SSL)
-#include "webrtc/base/sslconfig.h"
-#if defined(SSL_USE_OPENSSL)
 #include <openssl/rand.h>
-#else
-#if defined(WEBRTC_WIN)
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <ntsecapi.h>
-#endif  // WEBRTC_WIN
-#endif  // else
-#endif  // FEATURE_ENABLED_SSL
 
 #include "webrtc/base/base64.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/timeutils.h"
 
 // Protect against max macro inclusion.
 #undef max
 
 namespace rtc {
 
 // Base class for RNG implementations.
 class RandomGenerator {
  public:
   virtual ~RandomGenerator() {}
   virtual bool Init(const void* seed, size_t len) = 0;
   virtual bool Generate(void* buf, size_t len) = 0;
 };
 
-#if defined(SSL_USE_OPENSSL)
 // The OpenSSL RNG.
 class SecureRandomGenerator : public RandomGenerator {
  public:
   SecureRandomGenerator() {}
   ~SecureRandomGenerator() override {}
   bool Init(const void* seed, size_t len) override { return true; }
   bool Generate(void* buf, size_t len) override {
     return (RAND_bytes(reinterpret_cast<unsigned char*>(buf), len) > 0);
   }
 };
 
-#else
-#if defined(WEBRTC_WIN)
-class SecureRandomGenerator : public RandomGenerator {
- public:
-  SecureRandomGenerator() : advapi32_(NULL), rtl_gen_random_(NULL) {}
-  ~SecureRandomGenerator() {
-    FreeLibrary(advapi32_);
-  }
-
-  virtual bool Init(const void* seed, size_t seed_len) {
-    // We don't do any additional seeding on Win32, we just use the CryptoAPI
-    // RNG (which is exposed as a hidden function off of ADVAPI32 so that we
-    // don't need to drag in all of CryptoAPI)
-    if (rtl_gen_random_) {
-      return true;
-    }
-
-    advapi32_ = LoadLibrary(L"advapi32.dll");
-    if (!advapi32_) {
-      return false;
-    }
-
-    rtl_gen_random_ = reinterpret_cast<RtlGenRandomProc>(
-        GetProcAddress(advapi32_, "SystemFunction036"));
-    if (!rtl_gen_random_) {
-      FreeLibrary(advapi32_);
-      return false;
-    }
-
-    return true;
-  }
-  virtual bool Generate(void* buf, size_t len) {
-    if (!rtl_gen_random_ && !Init(NULL, 0)) {
-      return false;
-    }
-    return (rtl_gen_random_(buf, static_cast<int>(len)) != FALSE);
-  }
-
- private:
-  typedef BOOL (WINAPI *RtlGenRandomProc)(PVOID, ULONG);
-  HINSTANCE advapi32_;
-  RtlGenRandomProc rtl_gen_random_;
-};
-
-#elif !defined(FEATURE_ENABLE_SSL)
-
-// No SSL implementation -- use rand()
-class SecureRandomGenerator : public RandomGenerator {
- public:
-  virtual bool Init(const void* seed, size_t len) {
-    if (len >= 4) {
-      srand(*reinterpret_cast<const int*>(seed));
-    } else {
-      srand(*reinterpret_cast<const char*>(seed));
-    }
-    return true;
-  }
-  virtual bool Generate(void* buf, size_t len) {
-    char* bytes = reinterpret_cast<char*>(buf);
-    for (size_t i = 0; i < len; ++i) {
-      bytes[i] = static_cast<char>(rand());
-    }
-    return true;
-  }
-};
-
-#else
-
-#error No SSL implementation has been selected!
-
-#endif  // WEBRTC_WIN
-#endif
-
 // A test random generator, for predictable output.
 class TestRandomGenerator : public RandomGenerator {
  public:
   TestRandomGenerator() : seed_(7) {
   }
   ~TestRandomGenerator() override {
   }
   bool Init(const void* seed, size_t len) override { return true; }
   bool Generate(void* buf, size_t len) override {
     for (size_t i = 0; i < len; ++i) {
@@ skipping 151 matching lines @@
   } while (id == 0);
   return id;
 }
 
 double CreateRandomDouble() {
   return CreateRandomId() / (std::numeric_limits<uint32_t>::max() +
                              std::numeric_limits<double>::epsilon());
 }
 
 }  // namespace rtc