chrome/browser/net/cookie_store_util.cc

   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/profiles/profile.h"
  16 #include "chrome/browser/profiles/profile_manager.h"
  17 #include "chrome/common/chrome_constants.h"
  18 #include "chrome/common/chrome_switches.h"
  19 #include "components/os_crypt/os_crypt.h"
  20 #include "content/public/browser/browser_thread.h"
  21 #include "content/public/browser/cookie_store_factory.h"
  22 #include "content/public/browser/notification_service.h"
  23 #include "content/public/common/content_constants.h"
  24 #include "extensions/common/constants.h"
  25 #include "net/extras/sqlite/cookie_crypto_delegate.h"
  26
  27 using content::BrowserThread;
  28
  29 namespace {
  30
  31 class ChromeCookieMonsterDelegate : public net::CookieMonsterDelegate {
  32  public:
  33   explicit ChromeCookieMonsterDelegate(Profile* profile)
  34       : profile_getter_(
  35           base::Bind(&GetProfileOnUI, g_browser_process->profile_manager(),
  36                      profile)) {
  37     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  38     DCHECK(profile);
  39   }
  40
  41   // net::CookieMonster::Delegate implementation.
  42   void OnCookieChanged(
  43       const net::CanonicalCookie& cookie,
  44       bool removed,
  45       net::CookieMonster::Delegate::ChangeCause cause) override {
  46     BrowserThread::PostTask(
  47         BrowserThread::UI, FROM_HERE,
  48         base::Bind(&ChromeCookieMonsterDelegate::OnCookieChangedAsyncHelper,
  49                    this, cookie, removed, cause));
  50   }
  51
  52  private:
  53   ~ChromeCookieMonsterDelegate() override {}
  54
  55   static Profile* GetProfileOnUI(ProfileManager* profile_manager,
  56                                  Profile* profile) {
  57     if (profile_manager->IsValidProfile(profile))
  58       return profile;
  59     return NULL;
  60   }
  61
  62   void OnCookieChangedAsyncHelper(
  63       const net::CanonicalCookie& cookie,
  64       bool removed,
  65       net::CookieMonster::Delegate::ChangeCause cause) {
  66     Profile* profile = profile_getter_.Run();
  67     if (profile) {
  68       ChromeCookieDetails cookie_details(&cookie, removed, cause);
  69       content::NotificationService::current()->Notify(
  70           chrome::NOTIFICATION_COOKIE_CHANGED,
  71           content::Source<Profile>(profile),
  72           content::Details<ChromeCookieDetails>(&cookie_details));
  73     }
  74   }
  75
  76   const base::Callback<Profile*(void)> profile_getter_;
  77 };
  78
  79 }  // namespace
  80
  81 namespace chrome_browser_net {
  82
  83 net::CookieMonsterDelegate* CreateCookieDelegate(Profile* profile) {
  84   return new EvictedDomainCookieCounter(
  85       new ChromeCookieMonsterDelegate(profile));
  86 }
  87
  88 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
  89 namespace {
  90
  91 // Use the operating system's mechanisms to encrypt cookies before writing
  92 // them to persistent store.  Currently this only is done with desktop OS's
  93 // because ChromeOS and Android already protect the entire profile contents.
  94 //
  95 // TODO(bcwhite): Enable on MACOSX -- requires all Cookie tests to call
  96 // OSCrypt::UseMockKeychain or will hang waiting for user input.
  97 class CookieOSCryptoDelegate : public net::CookieCryptoDelegate {
  98  public:
  99   bool EncryptString(const std::string& plaintext,
 100                      std::string* ciphertext) override;
 101   bool DecryptString(const std::string& ciphertext,
 102                      std::string* plaintext) override;
 103 };
 104
 105 bool CookieOSCryptoDelegate::EncryptString(const std::string& plaintext,
 106                                            std::string* ciphertext) {
 107   return OSCrypt::EncryptString(plaintext, ciphertext);
 108 }
 109
 110 bool CookieOSCryptoDelegate::DecryptString(const std::string& ciphertext,
 111                                            std::string* plaintext) {
 112   return OSCrypt::DecryptString(ciphertext, plaintext);
 113 }
 114
 115 // Using a LazyInstance is safe here because this class is stateless and
 116 // requires 0 initialization.
 117 base::LazyInstance<CookieOSCryptoDelegate> g_cookie_crypto_delegate =
 118     LAZY_INSTANCE_INITIALIZER;
 119
 120 }  // namespace
 121
 122 net::CookieCryptoDelegate* GetCookieCryptoDelegate() {
 123   return g_cookie_crypto_delegate.Pointer();
 124 }
 125 #else  // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
 126 net::CookieCryptoDelegate* GetCookieCryptoDelegate() {
 127   return NULL;
 128 }
 129 #endif  // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
 130
 131 }  // namespace chrome_browser_net