Home | History | Annotate | Download | only in net 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/net/cookie_store_util.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/callback.h"
      9 #include "base/command_line.h"
     10 #include "base/lazy_instance.h"
     11 #include "chrome/browser/browser_process.h"
     12 #include "chrome/browser/chrome_notification_types.h"
     13 #include "chrome/browser/net/chrome_cookie_notification_details.h"
     14 #include "chrome/browser/net/evicted_domain_cookie_counter.h"
     15 #include "chrome/browser/prerender/prerender_manager.h"
     16 #include "chrome/browser/prerender/prerender_manager_factory.h"
     17 #include "chrome/browser/profiles/profile.h"
     18 #include "chrome/browser/profiles/profile_manager.h"
     19 #include "chrome/common/chrome_constants.h"
     20 #include "chrome/common/chrome_switches.h"
     21 #include "components/os_crypt/os_crypt.h"
     22 #include "content/public/browser/browser_thread.h"
     23 #include "content/public/browser/cookie_crypto_delegate.h"
     24 #include "content/public/browser/cookie_store_factory.h"
     25 #include "content/public/browser/notification_service.h"
     26 #include "content/public/common/content_constants.h"
     27 #include "extensions/common/constants.h"
     28 
     29 using content::BrowserThread;
     30 
     31 namespace {
     32 
     33 class ChromeCookieMonsterDelegate : public net::CookieMonsterDelegate {
     34  public:
     35   explicit ChromeCookieMonsterDelegate(Profile* profile)
     36       : profile_getter_(
     37           base::Bind(&GetProfileOnUI, g_browser_process->profile_manager(),
     38                      profile)) {
     39     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     40     DCHECK(profile);
     41   }
     42 
     43   // net::CookieMonster::Delegate implementation.
     44   virtual void OnCookieChanged(
     45       const net::CanonicalCookie& cookie,
     46       bool removed,
     47       net::CookieMonster::Delegate::ChangeCause cause) OVERRIDE {
     48     BrowserThread::PostTask(
     49         BrowserThread::UI, FROM_HERE,
     50         base::Bind(&ChromeCookieMonsterDelegate::OnCookieChangedAsyncHelper,
     51                    this, cookie, removed, cause));
     52   }
     53 
     54   virtual void OnLoaded() OVERRIDE {
     55     BrowserThread::PostTask(
     56         BrowserThread::UI, FROM_HERE,
     57         base::Bind(&ChromeCookieMonsterDelegate::OnLoadedAsyncHelper,
     58                    this));
     59   }
     60 
     61  private:
     62   virtual ~ChromeCookieMonsterDelegate() {}
     63 
     64   static Profile* GetProfileOnUI(ProfileManager* profile_manager,
     65                                  Profile* profile) {
     66     if (profile_manager->IsValidProfile(profile))
     67       return profile;
     68     return NULL;
     69   }
     70 
     71   void OnCookieChangedAsyncHelper(
     72       const net::CanonicalCookie& cookie,
     73       bool removed,
     74       net::CookieMonster::Delegate::ChangeCause cause) {
     75     Profile* profile = profile_getter_.Run();
     76     if (profile) {
     77       ChromeCookieDetails cookie_details(&cookie, removed, cause);
     78       content::NotificationService::current()->Notify(
     79           chrome::NOTIFICATION_COOKIE_CHANGED,
     80           content::Source<Profile>(profile),
     81           content::Details<ChromeCookieDetails>(&cookie_details));
     82     }
     83   }
     84 
     85   void OnLoadedAsyncHelper() {
     86     Profile* profile = profile_getter_.Run();
     87     if (profile) {
     88       prerender::PrerenderManager* prerender_manager =
     89           prerender::PrerenderManagerFactory::GetForProfile(profile);
     90       if (prerender_manager)
     91         prerender_manager->OnCookieStoreLoaded();
     92     }
     93   }
     94 
     95   const base::Callback<Profile*(void)> profile_getter_;
     96 };
     97 
     98 }  // namespace
     99 
    100 namespace chrome_browser_net {
    101 
    102 bool IsCookieRecordMode() {
    103   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
    104   // Only allow Record Mode if we are in a Debug build or where we are running
    105   // a cycle, and the user has limited control.
    106   return command_line.HasSwitch(switches::kRecordMode) &&
    107       chrome::kRecordModeEnabled;
    108 }
    109 
    110 bool ShouldUseInMemoryCookiesAndCache() {
    111   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
    112   return IsCookieRecordMode() ||
    113       command_line.HasSwitch(switches::kPlaybackMode);
    114 }
    115 
    116 net::CookieMonsterDelegate* CreateCookieDelegate(Profile* profile) {
    117   return new EvictedDomainCookieCounter(
    118       new ChromeCookieMonsterDelegate(profile));
    119 }
    120 
    121 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
    122 namespace {
    123 
    124 // Use the operating system's mechanisms to encrypt cookies before writing
    125 // them to persistent store.  Currently this only is done with desktop OS's
    126 // because ChromeOS and Android already protect the entire profile contents.
    127 //
    128 // TODO(bcwhite): Enable on MACOSX -- requires all Cookie tests to call
    129 // OSCrypt::UseMockKeychain or will hang waiting for user input.
    130 class CookieOSCryptoDelegate : public content::CookieCryptoDelegate {
    131  public:
    132   virtual bool EncryptString(const std::string& plaintext,
    133                              std::string* ciphertext) OVERRIDE;
    134   virtual bool DecryptString(const std::string& ciphertext,
    135                              std::string* plaintext) OVERRIDE;
    136 };
    137 
    138 bool CookieOSCryptoDelegate::EncryptString(const std::string& plaintext,
    139                                            std::string* ciphertext) {
    140   return OSCrypt::EncryptString(plaintext, ciphertext);
    141 }
    142 
    143 bool CookieOSCryptoDelegate::DecryptString(const std::string& ciphertext,
    144                                            std::string* plaintext) {
    145   return OSCrypt::DecryptString(ciphertext, plaintext);
    146 }
    147 
    148 // Using a LazyInstance is safe here because this class is stateless and
    149 // requires 0 initialization.
    150 base::LazyInstance<CookieOSCryptoDelegate> g_cookie_crypto_delegate =
    151     LAZY_INSTANCE_INITIALIZER;
    152 
    153 }  // namespace
    154 
    155 content::CookieCryptoDelegate* GetCookieCryptoDelegate() {
    156   return g_cookie_crypto_delegate.Pointer();
    157 }
    158 #else  // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
    159 content::CookieCryptoDelegate* GetCookieCryptoDelegate() {
    160   return NULL;
    161 }
    162 #endif  // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
    163 
    164 }  // namespace chrome_browser_net
    165