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

net/base/cookie_monster.h

 // 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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_BASE_COOKIE_MONSTER_H_
 #define NET_BASE_COOKIE_MONSTER_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #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"
 #include "base/time.h"
 #include "net/base/cookie_store.h"
 
 class GURL;
+class Histogram;
 
 namespace net {
 
 // The cookie monster is the system for storing and retrieving cookies. It has
 // an in-memory list of all cookies, and synchronizes non-session cookies to an
 // optional permanent storage that implements the PersistentCookieStore
 // interface.
 //
 // This class IS thread-safe. Normally, it is only used on the I/O thread, but
 // is also accessed directly through Automation for UI testing.
@@ skipping 57 matching lines @@
   typedef std::vector<CanonicalCookie> CookieList;
 
   // The store passed in should not have had Init() called on it yet. This
   // class will take care of initializing it. The backing store is NOT owned by
   // this class, but it must remain valid for the duration of the cookie
   // monster's existence. If |store| is NULL, then no backing store will be
   // updated. If |delegate| is non-NULL, it will be notified on
   // 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);
 
   // Returns true if a domain string represents a host-only cookie,
   // i.e. it doesn't begin with a leading '.' character.
   static bool DomainIsHostOnly(const std::string& domain_string);
 
   // CookieStore implementation.
 
@@ skipping 306 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(CookieMonster);
 };
 
 class CookieMonster::CanonicalCookie {
  public:
 
   // These constructors do no validation or canonicalization of their inputs;
   // 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,
                   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) {
-  }
+                  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.
   // Canonicalizes and validates inputs.  May return NULL if an attribute
   // value is invalid.
   static CanonicalCookie* Create(
       const GURL& url, const std::string& name, const std::string& value,
       const std::string& domain, const std::string& path,
       const base::Time& creation_time, const base::Time& expiration_time,
       bool secure, bool http_only);
@@ skipping 177 matching lines @@
  protected:
   PersistentCookieStore() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_