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

net/base/cookie_monster.cc

 // 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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 30 matching lines @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "net/base/cookie_monster.h"
 
 #include <algorithm>
 
 #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"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domain.h"
 
 // #define COOKIE_LOGGING_ENABLED
@@ skipping 1629 matching lines @@
   for (PairList::const_iterator it = pairs_.begin();
        it != pairs_.end(); ++it) {
     out.append(it->first);
     out.append("=");
     out.append(it->second);
     out.append("; ");
   }
   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()),
       value_(pc.Value()),
       path_(CanonPath(url, pc)),
       creation_date_(Time::Now()),
       last_access_date_(Time()),
       has_expires_(pc.HasExpires()),
       secure_(pc.IsSecure()),
       httponly_(pc.IsHttpOnly()) {
   if (has_expires_)
     expiry_date_ = CanonExpiration(pc, creation_date_, CookieOptions());
 
   // Do the best we can with the domain.
   std::string cookie_domain;
   std::string domain_string;
   if (pc.HasDomain()) {
     domain_string = pc.Domain();
   }
   bool result
       = GetCookieDomainWithString(url, domain_string,
                                   &cookie_domain);
   // Caller is responsible for passing in good arguments.
   DCHECK(result);
   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,
       const base::Time& creation_time, const base::Time& expiration_time,
       bool secure, bool http_only) {
   // Expect valid attribute tokens and values, as defined by the ParsedCookie
   // logic, otherwise don't create the cookie.
   std::string parsed_name = ParsedCookie::ParseTokenString(name);
   if (parsed_name != name)
     return NULL;
@@ skipping 105 matching lines @@
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   return StringPrintf("name: %s value: %s domain: %s path: %s creation: %"
                       PRId64,
                       name_.c_str(), value_.c_str(),
                       domain_.c_str(), path_.c_str(),
                       static_cast<int64>(creation_date_.ToTimeT()));
 }
 
 }  // namespace