Move CanonicalCookie into separate files

chrome/browser/extensions/api/cookies/cookies_helpers.cc

 // Copyright (c) 2012 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.
 
 // Implements common functionality for the Chrome Extensions Cookies API.
 
 #include "chrome/browser/extensions/api/cookies/cookies_helpers.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/cookies/cookies_api_constants.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
+#include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_util.h"
 
 namespace extensions {
 
 namespace keys = cookies_api_constants;
 
 namespace cookies_helpers {
 
 static const char kOriginalProfileStoreId[] = "0";
 static const char kOffTheRecordProfileStoreId[] = "1";
@@ skipping 11 matching lines @@
     return profile->GetOffTheRecordProfile();
   return NULL;
 }
 
 const char* GetStoreIdFromProfile(Profile* profile) {
   DCHECK(profile);
   return profile->IsOffTheRecord() ?
       kOffTheRecordProfileStoreId : kOriginalProfileStoreId;
 }
 
-DictionaryValue* CreateCookieValue(
-    const net::CookieMonster::CanonicalCookie& cookie,
-    const std::string& store_id) {
+DictionaryValue* CreateCookieValue(const net::CanonicalCookie& cookie,
+                                   const std::string& store_id) {
   DictionaryValue* result = new DictionaryValue();
 
   // A cookie is a raw byte sequence. By explicitly parsing it as UTF8, we
   // apply error correction, so the string can be safely passed to the
   // renderer.
   result->SetString(keys::kNameKey, UTF8ToUTF16(cookie.Name()));
   result->SetString(keys::kValueKey, UTF8ToUTF16(cookie.Value()));
   result->SetString(keys::kDomainKey, cookie.Domain());
   result->SetBoolean(keys::kHostOnlyKey,
                      net::cookie_util::DomainIsHostOnly(cookie.Domain()));
@@ skipping 29 matching lines @@
   DCHECK(cookie_store);
   net::CookieMonster* monster = cookie_store->GetCookieMonster();
   if (!url.is_empty()) {
     DCHECK(url.is_valid());
     monster->GetAllCookiesForURLAsync(url, callback);
   } else {
     monster->GetAllCookiesAsync(callback);
   }
 }
 
-GURL GetURLFromCanonicalCookie(
-    const net::CookieMonster::CanonicalCookie& cookie) {
+GURL GetURLFromCanonicalCookie(const net::CanonicalCookie& cookie) {
   const std::string& domain_key = cookie.Domain();
   const std::string scheme =
       cookie.IsSecure() ? chrome::kHttpsScheme : chrome::kHttpScheme;
   const std::string host =
       domain_key.find('.') != 0 ? domain_key : domain_key.substr(1);
   return GURL(scheme + content::kStandardSchemeSeparator + host + "/");
 }
 
 void AppendMatchingCookiesToList(
     const net::CookieList& all_cookies,
@@ skipping 24 matching lines @@
         ExtensionTabUtil::GetTabId(
             tab_strip->GetTabContentsAt(i)->web_contents())));
   }
 }
 
 MatchFilter::MatchFilter(const DictionaryValue* details)
     : details_(details) {
   DCHECK(details_);
 }
 
-bool MatchFilter::MatchesCookie(
-    const net::CookieMonster::CanonicalCookie& cookie) {
+bool MatchFilter::MatchesCookie(const net::CanonicalCookie& cookie) {
   return MatchesString(keys::kNameKey, cookie.Name()) &&
          MatchesDomain(cookie.Domain()) &&
          MatchesString(keys::kPathKey, cookie.Path()) &&
          MatchesBoolean(keys::kSecureKey, cookie.IsSecure()) &&
          MatchesBoolean(keys::kSessionKey, !cookie.IsPersistent());
 }
 
 bool MatchFilter::MatchesString(const char* key, const std::string& value) {
   if (!details_->HasKey(key))
     return true;
@@ skipping 32 matching lines @@
     if (sub_domain == filter_value)
       return true;
     const size_t next_dot = sub_domain.find('.', 1);  // Skip over leading dot.
     sub_domain.erase(0, next_dot);
   }
   return false;
 }
 
 }  // namespace cookies_helpers
 }  // namespace extension