FBTF: Move a bunch of code to the headers and remove includes.

BUG=none
TEST=compiles

Review URL: http://codereview.chromium.org/3412016

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@60208 0039d316-1c4b-4281-b951-d872f2087c98

32 files changed, 203 insertions, 92 deletions

diff --git a/net/base/cookie_monster.cc b/net/base/cookie_monster.cc
index 28d1e55..3353019 100644
--- a/net/base/cookie_monster.cc
+++ b/net/base/cookie_monster.cc
@@ -48,6 +48,7 @@
 
 #include "base/basictypes.h"
 #include "base/format_macros.h"
+#include "base/histogram.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_tokenizer.h"
@@ -1697,6 +1698,31 @@ std::string CookieMonster::ParsedCookie::DebugString() const {
   return out;
 }
 
+CookieMonster::CanonicalCookie::CanonicalCookie() {
+}
+
+CookieMonster::CanonicalCookie::CanonicalCookie(const std::string& name,
+                                                const std::string& value,
+                                                const std::string& domain,
+                                                const std::string& path,
+                                                bool secure,
+                                                bool httponly,
+                                                const base::Time& creation,
+                                                const base::Time& last_access,
+                                                bool has_expires,
+                                                const base::Time& expires)
+    : name_(name),
+    value_(value),
+    domain_(domain),
+    path_(path),
+    creation_date_(creation),
+    last_access_date_(last_access),
+    expiry_date_(expires),
+    has_expires_(has_expires),
+    secure_(secure),
+    httponly_(httponly) {
+}
+
 CookieMonster::CanonicalCookie::CanonicalCookie(const GURL& url,
                                                 const ParsedCookie& pc)
     : name_(pc.Name()),
@@ -1724,6 +1750,23 @@ CookieMonster::CanonicalCookie::CanonicalCookie(const GURL& url,
   domain_ = cookie_domain;
 }
 
+CookieMonster::CookieMonster(PersistentCookieStore* store,
+                             Delegate* delegate,
+                             int last_access_threshold_milliseconds)
+    : initialized_(false),
+    use_effective_domain_key_scheme_(use_effective_domain_key_default_),
+    store_(store),
+    last_access_threshold_(base::TimeDelta::FromMilliseconds(
+        last_access_threshold_milliseconds)),
+    delegate_(delegate),
+    last_statistic_record_time_(base::Time::Now()) {
+  InitializeHistograms();
+  SetDefaultCookieableSchemes();
+}
+
+CookieMonster::CanonicalCookie::~CanonicalCookie() {
+}
+
 CookieMonster::CanonicalCookie* CookieMonster::CanonicalCookie::Create(
       const GURL& url, const std::string& name, const std::string& value,
       const std::string& domain, const std::string& path,
diff --git a/net/base/cookie_monster.h b/net/base/cookie_monster.h
index febf147..8063876 100644
--- a/net/base/cookie_monster.h
+++ b/net/base/cookie_monster.h
@@ -15,7 +15,6 @@
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
-#include "base/histogram.h"
 #include "base/lock.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
@@ -23,6 +22,7 @@
 #include "net/base/cookie_store.h"
 
 class GURL;
+class Histogram;
 
 namespace net {
 
@@ -100,21 +100,10 @@ class CookieMonster : public CookieStore {
   // creation/deletion of cookies.
   CookieMonster(PersistentCookieStore* store, Delegate* delegate);
 
-#ifdef UNIT_TEST
+  // Only used during unit testing.
   CookieMonster(PersistentCookieStore* store,
                 Delegate* delegate,
-                int last_access_threshold_milliseconds)
-      : initialized_(false),
-        use_effective_domain_key_scheme_(use_effective_domain_key_default_),
-        store_(store),
-        last_access_threshold_(base::TimeDelta::FromMilliseconds(
-            last_access_threshold_milliseconds)),
-        delegate_(delegate),
-        last_statistic_record_time_(base::Time::Now()) {
-    InitializeHistograms();
-    SetDefaultCookieableSchemes();
-  }
-#endif
+                int last_access_threshold_milliseconds);
 
   // Parses the string with the cookie time (very forgivingly).
   static base::Time ParseCookieTime(const std::string& time_string);
@@ -441,7 +430,7 @@ class CookieMonster::CanonicalCookie {
   // the resulting CanonicalCookies should not be relied on to be canonical
   // unless the caller has done appropriate validation and canonicalization
   // themselves.
-  CanonicalCookie() { }
+  CanonicalCookie();
   CanonicalCookie(const std::string& name,
                   const std::string& value,
                   const std::string& domain,
@@ -451,24 +440,15 @@ class CookieMonster::CanonicalCookie {
                   const base::Time& creation,
                   const base::Time& last_access,
                   bool has_expires,
-                  const base::Time& expires)
-      : name_(name),
-        value_(value),
-        domain_(domain),
-        path_(path),
-        creation_date_(creation),
-        last_access_date_(last_access),
-        expiry_date_(expires),
-        has_expires_(has_expires),
-        secure_(secure),
-        httponly_(httponly) {
-  }
+                  const base::Time& expires);
 
   // This constructor does canonicalization but not validation.
   // The result of this constructor should not be relied on in contexts
   // in which pre-validation of the ParsedCookie has not been done.
   CanonicalCookie(const GURL& url, const ParsedCookie& pc);
 
+  ~CanonicalCookie();
+
   // Supports the default copy constructor.
 
   // Creates a canonical cookie from unparsed attribute values.
diff --git a/net/base/dnssec_chain_verifier.cc b/net/base/dnssec_chain_verifier.cc
index a32c683..2dbacbc 100644
--- a/net/base/dnssec_chain_verifier.cc
+++ b/net/base/dnssec_chain_verifier.cc
@@ -10,6 +10,7 @@
 #include "base/sha2.h"
 #include "base/string_util.h"
 #include "net/base/dns_util.h"
+#include "net/base/dnssec_keyset.h"
 
 // We don't have a location for the spec yet, so we'll include it here until it
 // finds a better home.
@@ -139,6 +140,15 @@ static const uint16 kRootKeyID = 19036;
 
 namespace net {
 
+struct DNSSECChainVerifier::Zone {
+  base::StringPiece name;
+  // The number of consecutive labels which |name| shares with |target_|,
+  // counting right-to-left from the root.
+  unsigned matching_labels;
+  DNSSECKeySet trusted_keys;
+  Zone* prev;
+};
+
 DNSSECChainVerifier::DNSSECChainVerifier(const std::string& target,
                                          const base::StringPiece& chain)
     : current_zone_(NULL),
diff --git a/net/base/dnssec_chain_verifier.h b/net/base/dnssec_chain_verifier.h
index d896c6c..60376c0 100644
--- a/net/base/dnssec_chain_verifier.h
+++ b/net/base/dnssec_chain_verifier.h
@@ -10,7 +10,6 @@
 #include <vector>
 
 #include "base/string_piece.h"
-#include "net/base/dnssec_keyset.h"
 
 namespace net {
 
@@ -67,14 +66,7 @@ class DNSSECChainVerifier {
                                  base::StringPiece b);
 
  private:
-  struct Zone {
-    base::StringPiece name;
-    // The number of consecutive labels which |name| shares with |target_|,
-    // counting right-to-left from the root.
-    unsigned matching_labels;
-    DNSSECKeySet trusted_keys;
-    Zone* prev;
-  };
+  struct Zone;
 
   bool U8(uint8*);
   bool U16(uint16*);
diff --git a/net/base/dnssec_keyset.cc b/net/base/dnssec_keyset.cc
index 0d89ae1..70aa217 100644
--- a/net/base/dnssec_keyset.cc
+++ b/net/base/dnssec_keyset.cc
@@ -21,6 +21,9 @@ DNSSECKeySet::DNSSECKeySet()
     : ignore_timestamps_(false) {
 }
 
+DNSSECKeySet::~DNSSECKeySet() {
+}
+
 bool DNSSECKeySet::AddKey(const base::StringPiece& dnskey) {
   uint16 keyid = DNSKEYToKeyID(dnskey);
   std::string der_encoded = ASN1WrapDNSKEY(dnskey);
diff --git a/net/base/dnssec_keyset.h b/net/base/dnssec_keyset.h
index 7a44916..58bd288 100644
--- a/net/base/dnssec_keyset.h
+++ b/net/base/dnssec_keyset.h
@@ -17,6 +17,7 @@ namespace net {
 class DNSSECKeySet {
  public:
   DNSSECKeySet();
+  ~DNSSECKeySet();
 
   // AddKey adds a key to the trusted set.
   //   dnskey: the RRDATA of a DNSKEY.
diff --git a/net/base/ev_root_ca_metadata.cc b/net/base/ev_root_ca_metadata.cc
index 023b1fb..3aa02e5 100644
--- a/net/base/ev_root_ca_metadata.cc
+++ b/net/base/ev_root_ca_metadata.cc
@@ -281,4 +281,7 @@ EVRootCAMetadata::EVRootCAMetadata() {
 #endif
 }
 
+EVRootCAMetadata::~EVRootCAMetadata() {
+}
+
 }  // namespace net
diff --git a/net/base/ev_root_ca_metadata.h b/net/base/ev_root_ca_metadata.h
index 21f9729..e9e8130 100644
--- a/net/base/ev_root_ca_metadata.h
+++ b/net/base/ev_root_ca_metadata.h
@@ -44,7 +44,7 @@ class EVRootCAMetadata {
 
  private:
   EVRootCAMetadata();
-  ~EVRootCAMetadata() { }
+  ~EVRootCAMetadata();
 
   friend struct DefaultSingletonTraits<EVRootCAMetadata>;
 
diff --git a/net/base/host_mapping_rules.cc b/net/base/host_mapping_rules.cc
index a535d14..e7d72b2 100644
--- a/net/base/host_mapping_rules.cc
+++ b/net/base/host_mapping_rules.cc
@@ -12,8 +12,22 @@
 
 namespace net {
 
+struct HostMappingRules::MapRule {
+  MapRule() : replacement_port(-1) {}
+
+  std::string hostname_pattern;
+  std::string replacement_hostname;
+  int replacement_port;
+};
+
+struct HostMappingRules::ExclusionRule {
+  std::string hostname_pattern;
+};
+
 HostMappingRules::HostMappingRules() {}
 
+HostMappingRules::~HostMappingRules() {}
+
 bool HostMappingRules::RewriteHost(HostPortPair* host_port) const {
   // Check if the hostname was excluded.
   for (ExclusionRuleList::const_iterator it = exclusion_rules_.begin();
diff --git a/net/base/host_mapping_rules.h b/net/base/host_mapping_rules.h
index 9ab06fe..05f531f 100644
--- a/net/base/host_mapping_rules.h
+++ b/net/base/host_mapping_rules.h
@@ -17,6 +17,7 @@ class HostPortPair;
 class HostMappingRules {
  public:
   HostMappingRules();
+  ~HostMappingRules();
 
   // Modifies |*host_port| based on the current rules. Returns true if the
   // RequestInfo was modified, false otherwise.
@@ -36,17 +37,8 @@ class HostMappingRules {
   void SetRulesFromString(const std::string& rules_string);
 
  private:
-  struct MapRule {
-    MapRule() : replacement_port(-1) {}
-
-    std::string hostname_pattern;
-    std::string replacement_hostname;
-    int replacement_port;
-  };
-
-  struct ExclusionRule {
-    std::string hostname_pattern;
-  };
+  struct MapRule;
+  struct ExclusionRule;
 
   typedef std::vector<MapRule> MapRuleList;
   typedef std::vector<ExclusionRule> ExclusionRuleList;
diff --git a/net/base/io_buffer.cc b/net/base/io_buffer.cc
index b922733..dfd4d38 100644
--- a/net/base/io_buffer.cc
+++ b/net/base/io_buffer.cc
@@ -30,6 +30,9 @@ IOBufferWithSize::IOBufferWithSize(int size)
       size_(size) {
 }
 
+IOBufferWithSize::~IOBufferWithSize() {
+}
+
 StringIOBuffer::StringIOBuffer(const std::string& s)
     : IOBuffer(static_cast<char*>(NULL)),
       string_data_(s) {
diff --git a/net/base/io_buffer.h b/net/base/io_buffer.h
index f8fb328..527864b 100644
--- a/net/base/io_buffer.h
+++ b/net/base/io_buffer.h
@@ -46,7 +46,7 @@ class IOBufferWithSize : public IOBuffer {
   int size() const { return size_; }
 
  private:
-  ~IOBufferWithSize() {}
+  virtual ~IOBufferWithSize();
 
   int size_;
 };
@@ -60,7 +60,7 @@ class StringIOBuffer : public IOBuffer {
   int size() const { return string_data_.size(); }
 
  private:
-  ~StringIOBuffer();
+  virtual ~StringIOBuffer();
 
   std::string string_data_;
 };
@@ -88,7 +88,7 @@ class DrainableIOBuffer : public IOBuffer {
   int size() const { return size_; }
 
  private:
-  ~DrainableIOBuffer();
+  virtual ~DrainableIOBuffer();
 
   scoped_refptr<IOBuffer> base_;
   int size_;
@@ -112,7 +112,7 @@ class GrowableIOBuffer : public IOBuffer {
   char* StartOfBuffer();
 
  private:
-  ~GrowableIOBuffer();
+  virtual ~GrowableIOBuffer();
 
   scoped_ptr_malloc<char> real_data_;
   int capacity_;
@@ -132,7 +132,7 @@ class PickledIOBuffer : public IOBuffer {
   void Done();
 
  private:
-  ~PickledIOBuffer();
+  virtual ~PickledIOBuffer();
 
   Pickle pickle_;
 };
@@ -147,7 +147,7 @@ class WrappedIOBuffer : public IOBuffer {
   explicit WrappedIOBuffer(const char* data);
 
  protected:
-  ~WrappedIOBuffer();
+  virtual ~WrappedIOBuffer();
 };
 
 }  // namespace net
diff --git a/net/base/pem_tokenizer.cc b/net/base/pem_tokenizer.cc
index 0abe5db..6e83058 100644
--- a/net/base/pem_tokenizer.cc
+++ b/net/base/pem_tokenizer.cc
@@ -19,12 +19,21 @@ namespace net {
 
 using base::StringPiece;
 
+struct PEMTokenizer::PEMType {
+  std::string type;
+  std::string header;
+  std::string footer;
+};
+
 PEMTokenizer::PEMTokenizer(
     const StringPiece& str,
     const std::vector<std::string>& allowed_block_types) {
   Init(str, allowed_block_types);
 }
 
+PEMTokenizer::~PEMTokenizer() {
+}
+
 bool PEMTokenizer::GetNext() {
   while (pos_ != StringPiece::npos) {
     // Scan for the beginning of the next PEM encoded block.
diff --git a/net/base/pem_tokenizer.h b/net/base/pem_tokenizer.h
index 5074b20..b54337e 100644
--- a/net/base/pem_tokenizer.h
+++ b/net/base/pem_tokenizer.h
@@ -24,6 +24,7 @@ class PEMTokenizer {
   // |str| must remain valid for the duration of the PEMTokenizer.
   PEMTokenizer(const base::StringPiece& str,
                const std::vector<std::string>& allowed_block_types);
+  ~PEMTokenizer();
 
   // Attempts to decode the next PEM block in the string. Returns false if no
   // PEM blocks can be decoded. The decoded PEM block will be available via
@@ -46,11 +47,7 @@ class PEMTokenizer {
 
   // A simple cache of the allowed PEM header and footer for a given PEM
   // block type, so that it is only computed once.
-  struct PEMType {
-    std::string type;
-    std::string header;
-    std::string footer;
-  };
+  struct PEMType;
 
   // The string to search, which must remain valid for as long as this class
   // is around.
diff --git a/net/base/sdch_manager.cc b/net/base/sdch_manager.cc
index 07c839a..21cbe07 100644
--- a/net/base/sdch_manager.cc
+++ b/net/base/sdch_manager.cc
@@ -331,6 +331,9 @@ SdchManager::Dictionary::Dictionary(const std::string& dictionary_text,
         ports_(ports) {
 }
 
+SdchManager::Dictionary::~Dictionary() {
+}
+
 // static
 void SdchManager::GenerateHash(const std::string& dictionary_text,
     std::string* client_hash, std::string* server_hash) {
diff --git a/net/base/sdch_manager.h b/net/base/sdch_manager.h
index 4dd43ae..d53be00 100644
--- a/net/base/sdch_manager.h
+++ b/net/base/sdch_manager.h
@@ -175,7 +175,7 @@ class SdchManager {
                const std::string& client_hash, const GURL& url,
                const std::string& domain, const std::string& path,
                const base::Time& expiration, const std::set<int> ports);
-    ~Dictionary() {}
+    ~Dictionary();
 
     const GURL& url() const { return url_; }
     const std::string& client_hash() const { return client_hash_; }
diff --git a/net/base/ssl_config_service.cc b/net/base/ssl_config_service.cc
index 753f1c7..c20284f 100644
--- a/net/base/ssl_config_service.cc
+++ b/net/base/ssl_config_service.cc
@@ -15,6 +15,31 @@
 
 namespace net {
 
+SSLConfig::SSLConfig()
+    : rev_checking_enabled(true),  ssl2_enabled(false), ssl3_enabled(true),
+      tls1_enabled(true), dnssec_enabled(false), mitm_proxies_allowed(false),
+      false_start_enabled(true), send_client_cert(false),
+      verify_ev_cert(false), ssl3_fallback(false) {
+}
+
+SSLConfig::~SSLConfig() {
+}
+
+bool SSLConfig::IsAllowedBadCert(X509Certificate* cert) const {
+  for (size_t i = 0; i < allowed_bad_certs.size(); ++i) {
+    if (cert == allowed_bad_certs[i].cert)
+      return true;
+  }
+  return false;
+}
+
+SSLConfigService::SSLConfigService()
+    : observer_list_(ObserverList<Observer>::NOTIFY_EXISTING_ONLY) {
+}
+
+SSLConfigService::~SSLConfigService() {
+}
+
 // static
 SSLConfigService* SSLConfigService::CreateSystemSSLConfigService() {
 #if defined(OS_WIN)
diff --git a/net/base/ssl_config_service.h b/net/base/ssl_config_service.h
index f9d2245..f78e3df 100644
--- a/net/base/ssl_config_service.h
+++ b/net/base/ssl_config_service.h
@@ -18,12 +18,8 @@ namespace net {
 struct SSLConfig {
   // Default to revocation checking.
   // Default to SSL 2.0 off, SSL 3.0 on, and TLS 1.0 on.
-  SSLConfig()
-      : rev_checking_enabled(true),  ssl2_enabled(false), ssl3_enabled(true),
-        tls1_enabled(true), dnssec_enabled(false), mitm_proxies_allowed(false),
-        false_start_enabled(true), send_client_cert(false),
-        verify_ev_cert(false), ssl3_fallback(false) {
-  }
+  SSLConfig();
+  ~SSLConfig();
 
   bool rev_checking_enabled;  // True if server certificate revocation
                               // checking is enabled.
@@ -51,15 +47,7 @@ struct SSLConfig {
   };
 
   // Returns true if |cert| is one of the certs in |allowed_bad_certs|.
-  // TODO(wtc): Move this to a .cc file.  ssl_config_service.cc is Windows
-  // only right now, so I can't move it there.
-  bool IsAllowedBadCert(X509Certificate* cert) const {
-    for (size_t i = 0; i < allowed_bad_certs.size(); ++i) {
-      if (cert == allowed_bad_certs[i].cert)
-        return true;
-    }
-    return false;
-  }
+  bool IsAllowedBadCert(X509Certificate* cert) const;
 
   // Add any known-bad SSL certificate (with its cert status) to
   // |allowed_bad_certs| that should not trigger an ERR_CERT_* error when
@@ -108,8 +96,7 @@ class SSLConfigService : public base::RefCountedThreadSafe<SSLConfigService> {
     virtual ~Observer() {}
   };
 
-  SSLConfigService()
-      : observer_list_(ObserverList<Observer>::NOTIFY_EXISTING_ONLY) {}
+  SSLConfigService();
 
   // Create an instance of SSLConfigService which retrieves the configuration
   // from the system SSL configuration, or an instance of
@@ -157,7 +144,7 @@ class SSLConfigService : public base::RefCountedThreadSafe<SSLConfigService> {
  protected:
   friend class base::RefCountedThreadSafe<SSLConfigService>;
 
-  virtual ~SSLConfigService() {}
+  virtual ~SSLConfigService();
 
   // SetFlags sets the values of several flags based on global configuration.
   static void SetSSLConfigFlags(SSLConfig*);
diff --git a/net/base/ssl_config_service_defaults.cc b/net/base/ssl_config_service_defaults.cc
new file mode 100644
index 0000000..9a3afa2
--- /dev/null
+++ b/net/base/ssl_config_service_defaults.cc
@@ -0,0 +1,20 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/base/ssl_config_service_defaults.h"
+
+namespace net {
+
+SSLConfigServiceDefaults::SSLConfigServiceDefaults() {
+}
+
+void SSLConfigServiceDefaults::GetSSLConfig(SSLConfig* config) {
+  *config = default_config_;
+  SetSSLConfigFlags(config);
+}
+
+SSLConfigServiceDefaults::~SSLConfigServiceDefaults() {
+}
+
+}  // namespace net
diff --git a/net/base/ssl_config_service_defaults.h b/net/base/ssl_config_service_defaults.h
index 58d0f2d..6d96a44 100644
--- a/net/base/ssl_config_service_defaults.h
+++ b/net/base/ssl_config_service_defaults.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -15,16 +15,13 @@ namespace net {
 // implementation of SSLConfigService yet.
 class SSLConfigServiceDefaults : public SSLConfigService {
  public:
-  SSLConfigServiceDefaults() {}
+  SSLConfigServiceDefaults();
 
   // Store default SSL config settings in |config|.
-  virtual void GetSSLConfig(SSLConfig* config) {
-    *config = default_config_;
-    SetSSLConfigFlags(config);
-  }
+  virtual void GetSSLConfig(SSLConfig* config);
 
  private:
-  virtual ~SSLConfigServiceDefaults() {}
+  virtual ~SSLConfigServiceDefaults();
 
   // Default value of prefs.
   const SSLConfig default_config_;
diff --git a/net/base/transport_security_state.cc b/net/base/transport_security_state.cc
index ad6a503..a0d2794 100644
--- a/net/base/transport_security_state.cc
+++ b/net/base/transport_security_state.cc
@@ -347,6 +347,9 @@ void TransportSecurityState::DeleteSince(const base::Time& time) {
     DirtyNotify();
 }
 
+TransportSecurityState::~TransportSecurityState() {
+}
+
 void TransportSecurityState::DirtyNotify() {
   if (delegate_)
     delegate_->StateIsDirty(this);
diff --git a/net/base/transport_security_state.h b/net/base/transport_security_state.h
index 3b67c98..b7db72c 100644
--- a/net/base/transport_security_state.h
+++ b/net/base/transport_security_state.h
@@ -93,7 +93,7 @@ class TransportSecurityState :
   friend class base::RefCountedThreadSafe<TransportSecurityState>;
   FRIEND_TEST_ALL_PREFIXES(TransportSecurityStateTest, IsPreloaded);
 
-  ~TransportSecurityState() {}
+  ~TransportSecurityState();
 
   // If we have a callback configured, call it to let our serialiser know that
   // our state is dirty.
diff --git a/net/base/upload_data_stream.cc b/net/base/upload_data_stream.cc
index edcff19..329058c 100644
--- a/net/base/upload_data_stream.cc
+++ b/net/base/upload_data_stream.cc
@@ -6,6 +6,7 @@
 
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
diff --git a/net/base/upload_data_stream.h b/net/base/upload_data_stream.h
index 646335f..0d179d2 100644
--- a/net/base/upload_data_stream.h
+++ b/net/base/upload_data_stream.h
@@ -6,11 +6,12 @@
 #define NET_BASE_UPLOAD_DATA_STREAM_H_
 #pragma once
 
-#include "net/base/file_stream.h"
+#include "base/scoped_ptr.h"
 #include "net/base/upload_data.h"
 
 namespace net {
 
+class FileStream;
 class IOBuffer;
 
 class UploadDataStream {
diff --git a/net/base/x509_cert_types.cc b/net/base/x509_cert_types.cc
index 9c1369d..5dfc57a 100644
--- a/net/base/x509_cert_types.cc
+++ b/net/base/x509_cert_types.cc
@@ -36,6 +36,13 @@ bool match(const std::vector<std::string> &rdn1,
   return true;
 }
 
+CertPrincipal::CertPrincipal() {
+}
+
+CertPrincipal::CertPrincipal(const std::string& name) : common_name(name) {}
+
+CertPrincipal::~CertPrincipal() {
+}
 
 bool CertPrincipal::Matches(const CertPrincipal& against) const {
   return match(common_name, against.common_name) &&
@@ -81,6 +88,12 @@ std::ostream& operator<<(std::ostream& s, const CertPrincipal& p) {
   return s << "]";
 }
 
+CertPolicy::CertPolicy() {
+}
+
+CertPolicy::~CertPolicy() {
+}
+
 CertPolicy::Judgment CertPolicy::Check(
     X509Certificate* cert) const {
   // It shouldn't matter which set we check first, but we check denied first
diff --git a/net/base/x509_cert_types.h b/net/base/x509_cert_types.h
index b7540c4..43d05dd 100644
--- a/net/base/x509_cert_types.h
+++ b/net/base/x509_cert_types.h
@@ -53,8 +53,9 @@ class SHA1FingerprintLessThan
 
 // CertPrincipal represents the issuer or subject field of an X.509 certificate.
 struct CertPrincipal {
-  CertPrincipal() { }
-  explicit CertPrincipal(const std::string& name) : common_name(name) { }
+  CertPrincipal();
+  explicit CertPrincipal(const std::string& name);
+  ~CertPrincipal();
 
   // Parses a BER-format DistinguishedName.
   bool ParseDistinguishedName(const void* ber_name_data, size_t length);
@@ -105,6 +106,9 @@ class CertPolicy {
     DENIED,
   };
 
+  CertPolicy();
+  ~CertPolicy();
+
   // Returns the judgment this policy makes about this certificate.
   Judgment Check(X509Certificate* cert) const;
 
diff --git a/net/http/http_stream_parser.h b/net/http/http_stream_parser.h
index 1ef7644..ec84d056 100644
--- a/net/http/http_stream_parser.h
+++ b/net/http/http_stream_parser.h
@@ -9,6 +9,7 @@
 #include <string>
 
 #include "base/basictypes.h"
+#include "net/base/completion_callback.h"
 #include "net/base/net_log.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_chunked_decoder.h"
diff --git a/net/net.gyp b/net/net.gyp
index 4788816..06105fa 100644
--- a/net/net.gyp
+++ b/net/net.gyp
@@ -161,6 +161,7 @@
         'base/ssl_client_auth_cache.h',
         'base/ssl_config_service.cc',
         'base/ssl_config_service.h',
+        'base/ssl_config_service_defaults.cc',
         'base/ssl_config_service_defaults.h',
         'base/ssl_config_service_mac.cc',
         'base/ssl_config_service_mac.h',
diff --git a/net/url_request/https_prober.cc b/net/url_request/https_prober.cc
index a7163ba..d69eaf3 100644
--- a/net/url_request/https_prober.cc
+++ b/net/url_request/https_prober.cc
@@ -9,6 +9,12 @@
 
 namespace net {
 
+HTTPSProber::HTTPSProber() {
+}
+
+HTTPSProber::~HTTPSProber() {
+}
+
 bool HTTPSProber::HaveProbed(const std::string& host) const {
   return probed_.find(host) != probed_.end();
 }
diff --git a/net/url_request/https_prober.h b/net/url_request/https_prober.h
index b85b126..28182c4 100644
--- a/net/url_request/https_prober.h
+++ b/net/url_request/https_prober.h
@@ -33,7 +33,8 @@ class HTTPSProberDelegate {
 // transparently upgrading from HTTP to HTTPS (for example, for SPDY).
 class HTTPSProber : public URLRequest::Delegate {
  public:
-  HTTPSProber() {}
+  HTTPSProber();
+  ~HTTPSProber();
 
   // HaveProbed returns true if the given host is known to have been probed
   // since the browser was last started.
diff --git a/net/url_request/url_request_data_job.cc b/net/url_request/url_request_data_job.cc
index ff52bb3..737f169 100644
--- a/net/url_request/url_request_data_job.cc
+++ b/net/url_request/url_request_data_job.cc
@@ -19,7 +19,6 @@ URLRequestDataJob::URLRequestDataJob(URLRequest* request)
     : URLRequestSimpleJob(request) {
 }
 
-
 bool URLRequestDataJob::GetData(std::string* mime_type,
                                 std::string* charset,
                                 std::string* data) const {
@@ -31,3 +30,5 @@ bool URLRequestDataJob::GetData(std::string* mime_type,
   return net::DataURL::Parse(url, mime_type, charset, data);
 }
 
+URLRequestDataJob::~URLRequestDataJob() {
+}
diff --git a/net/url_request/url_request_data_job.h b/net/url_request/url_request_data_job.h
index 80ea450..1bb868a 100644
--- a/net/url_request/url_request_data_job.h
+++ b/net/url_request/url_request_data_job.h
@@ -24,7 +24,7 @@ class URLRequestDataJob : public URLRequestSimpleJob {
   static URLRequest::ProtocolFactory Factory;
 
  private:
-  ~URLRequestDataJob() {}
+  ~URLRequestDataJob();
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestDataJob);
 };