chrome/browser/sessions/session_data_deleter.cc

   1 // Copyright 2013 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 "base/bind.h"
   6 #include "base/command_line.h"
   7 #include "chrome/browser/browser_shutdown.h"
   8 #include "chrome/browser/net/chrome_url_request_context.h"
   9 #include "chrome/browser/prefs/session_startup_pref.h"
  10 #include "chrome/browser/profiles/profile_io_data.h"
  11 #include "chrome/browser/ui/startup/startup_browser_creator.h"
  12 #include "content/public/browser/browser_context.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "content/public/browser/dom_storage_context.h"
  15 #include "content/public/browser/local_storage_usage_info.h"
  16 #include "content/public/browser/storage_partition.h"
  17 #include "net/cookies/cookie_monster.h"
  18 #include "net/cookies/cookie_store.h"
  19 #include "net/cookies/cookie_util.h"
  20 #include "webkit/browser/quota/special_storage_policy.h"
  21
  22 namespace {
  23
  24 void CookieDeleted(bool success) {
  25   DCHECK(success);
  26 }
  27
  28 class SessionDataDeleter
  29     : public base::RefCountedThreadSafe<SessionDataDeleter> {
  30  public:
  31   SessionDataDeleter(quota::SpecialStoragePolicy* storage_policy,
  32                      bool delete_only_by_session_only_policy);
  33
  34   void Run(content::StoragePartition* storage_partition,
  35            ProfileIOData* profile_io_data);
  36
  37  private:
  38   friend class base::RefCountedThreadSafe<SessionDataDeleter>;
  39   ~SessionDataDeleter();
  40
  41   // Deletes the local storage described by |usages| for origins which are
  42   // session-only.
  43   void ClearSessionOnlyLocalStorage(
  44       content::StoragePartition* storage_partition,
  45       const std::vector<content::LocalStorageUsageInfo>& usages);
  46
  47   // Deletes all cookies that are session only if
  48   // |delete_only_by_session_only_policy_| is false. Once completed or skipped,
  49   // this arranges for DeleteSessionOnlyOriginCookies to be called with a list
  50   // of all remaining cookies.
  51   void DeleteSessionCookiesOnIOThread(ProfileIOData* profile_io_data);
  52
  53   // Called when all session-only cookies have been deleted.
  54   void DeleteSessionCookiesDone(int num_deleted);
  55
  56   // Deletes the cookies in |cookies| that are for origins which are
  57   // session-only.
  58   void DeleteSessionOnlyOriginCookies(const net::CookieList& cookies);
  59
  60   base::WeakPtr<ChromeURLRequestContext> request_context_;
  61   scoped_refptr<quota::SpecialStoragePolicy> storage_policy_;
  62   const bool delete_only_by_session_only_policy_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(SessionDataDeleter);
  65 };
  66
  67 SessionDataDeleter::SessionDataDeleter(
  68     quota::SpecialStoragePolicy* storage_policy,
  69     bool delete_only_by_session_only_policy)
  70     : storage_policy_(storage_policy),
  71       delete_only_by_session_only_policy_(delete_only_by_session_only_policy) {}
  72
  73 void SessionDataDeleter::Run(content::StoragePartition* storage_partition,
  74                              ProfileIOData* profile_io_data) {
  75   storage_partition->GetDOMStorageContext()->GetLocalStorageUsage(
  76       base::Bind(&SessionDataDeleter::ClearSessionOnlyLocalStorage,
  77                  this,
  78                  storage_partition));
  79   content::BrowserThread::PostTask(
  80       content::BrowserThread::IO,
  81       FROM_HERE,
  82       base::Bind(&SessionDataDeleter::DeleteSessionCookiesOnIOThread,
  83                  this,
  84                  profile_io_data));
  85 }
  86
  87 SessionDataDeleter::~SessionDataDeleter() {}
  88
  89 void SessionDataDeleter::ClearSessionOnlyLocalStorage(
  90     content::StoragePartition* storage_partition,
  91     const std::vector<content::LocalStorageUsageInfo>& usages) {
  92   for (std::vector<content::LocalStorageUsageInfo>::const_iterator it =
  93            usages.begin();
  94        it != usages.end();
  95        ++it) {
  96     if (storage_policy_->IsStorageSessionOnly(it->origin))
  97       storage_partition->GetDOMStorageContext()->DeleteLocalStorage(it->origin);
  98   }
  99 }
 100
 101 void SessionDataDeleter::DeleteSessionCookiesOnIOThread(
 102     ProfileIOData* profile_io_data) {
 103   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 104   ChromeURLRequestContext* request_context =
 105       profile_io_data->GetMainRequestContext();
 106   request_context_ = request_context->GetWeakPtr();
 107   net::CookieMonster* cookie_monster =
 108       request_context_->cookie_store()->GetCookieMonster();
 109   if (delete_only_by_session_only_policy_) {
 110     cookie_monster->GetAllCookiesAsync(
 111         base::Bind(&SessionDataDeleter::DeleteSessionOnlyOriginCookies, this));
 112   } else {
 113     cookie_monster->DeleteSessionCookiesAsync(
 114         base::Bind(&SessionDataDeleter::DeleteSessionCookiesDone, this));
 115   }
 116 }
 117
 118 void SessionDataDeleter::DeleteSessionCookiesDone(int num_deleted) {
 119   ChromeURLRequestContext* request_context = request_context_.get();
 120   if (!request_context)
 121     return;
 122
 123   request_context->cookie_store()->GetCookieMonster()->GetAllCookiesAsync(
 124       base::Bind(&SessionDataDeleter::DeleteSessionOnlyOriginCookies, this));
 125 }
 126
 127 void SessionDataDeleter::DeleteSessionOnlyOriginCookies(
 128     const net::CookieList& cookies) {
 129   ChromeURLRequestContext* request_context = request_context_.get();
 130   if (!request_context)
 131     return;
 132
 133   net::CookieMonster* cookie_monster =
 134       request_context->cookie_store()->GetCookieMonster();
 135   for (net::CookieList::const_iterator it = cookies.begin();
 136        it != cookies.end();
 137        ++it) {
 138     if (storage_policy_->IsStorageSessionOnly(
 139             net::cookie_util::CookieOriginToURL(it->Domain(),
 140                                                 it->IsSecure()))) {
 141       cookie_monster->DeleteCanonicalCookieAsync(*it,
 142                                                  base::Bind(CookieDeleted));
 143     }
 144   }
 145 }
 146
 147 }  // namespace
 148
 149 void DeleteSessionOnlyData(Profile* profile) {
 150   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 151   if (browser_shutdown::IsTryingToQuit())
 152     return;
 153
 154 #if defined(OS_ANDROID)
 155   SessionStartupPref::Type startup_pref_type =
 156       SessionStartupPref::GetDefaultStartupType();
 157 #else
 158   SessionStartupPref::Type startup_pref_type =
 159       StartupBrowserCreator::GetSessionStartupPref(
 160           *CommandLine::ForCurrentProcess(), profile).type;
 161 #endif
 162
 163   scoped_refptr<SessionDataDeleter> deleter(
 164       new SessionDataDeleter(profile->GetSpecialStoragePolicy(),
 165                              startup_pref_type == SessionStartupPref::LAST));
 166   deleter->Run(
 167       Profile::GetDefaultStoragePartition(profile),
 168       ProfileIOData::FromResourceContext(profile->GetResourceContext()));
 169 }