CookieStore: Remove reference counting.

chrome/browser/sessions/session_data_deleter.cc

 // Copyright 2013 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.
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
-#include "chrome/browser/profiles/profile_io_data.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/cookies/cookie_store.h"
 #include "net/cookies/cookie_util.h"
 #include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace {
 
 void CookieDeleted(int num_cookies_deleted) {
   DCHECK_EQ(1, num_cookies_deleted);
 }
 
 class SessionDataDeleter
     : public base::RefCountedThreadSafe<SessionDataDeleter> {
  public:
   SessionDataDeleter(storage::SpecialStoragePolicy* storage_policy,
                      bool delete_only_by_session_only_policy);
 
-  void Run(content::StoragePartition* storage_partition,
-           ProfileIOData* profile_io_data);
+  void Run(
+      content::StoragePartition* storage_partition,
+      scoped_refptr<net::URLRequestContextGetter> url_request_context_getter);
 
  private:
   friend class base::RefCountedThreadSafe<SessionDataDeleter>;
   ~SessionDataDeleter();
 
   // Deletes the local storage described by |usages| for origins which are
   // session-only.
   void ClearSessionOnlyLocalStorage(
       content::StoragePartition* storage_partition,
       const std::vector<content::LocalStorageUsageInfo>& usages);
 
   // Deletes all cookies that are session only if
   // |delete_only_by_session_only_policy_| is false. Once completed or skipped,
   // this arranges for DeleteSessionOnlyOriginCookies to be called with a list
   // of all remaining cookies.
-  void DeleteSessionCookiesOnIOThread(ProfileIOData* profile_io_data);
+  void DeleteSessionCookiesOnIOThread(
+      scoped_refptr<net::URLRequestContextGetter> url_request_context_getter);
 
   // Called when all session-only cookies have been deleted.
-  void DeleteSessionCookiesDone(int num_deleted);
+  void DeleteSessionCookiesDone(net::CookieStore* cookie_store,
+                                int num_deleted);
 
   // Deletes the cookies in |cookies| that are for origins which are
   // session-only.
-  void DeleteSessionOnlyOriginCookies(const net::CookieList& cookies);
+  void DeleteSessionOnlyOriginCookies(net::CookieStore* cookie_store,
+                                      const net::CookieList& cookies);
 
-  scoped_refptr<net::CookieStore> cookie_store_;
   scoped_refptr<storage::SpecialStoragePolicy> storage_policy_;
   const bool delete_only_by_session_only_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionDataDeleter);
 };
 
 SessionDataDeleter::SessionDataDeleter(
     storage::SpecialStoragePolicy* storage_policy,
     bool delete_only_by_session_only_policy)
     : storage_policy_(storage_policy),
       delete_only_by_session_only_policy_(delete_only_by_session_only_policy) {
 }
 
-void SessionDataDeleter::Run(content::StoragePartition* storage_partition,
-                             ProfileIOData* profile_io_data) {
+void SessionDataDeleter::Run(
+    content::StoragePartition* storage_partition,
+    scoped_refptr<net::URLRequestContextGetter> url_request_context_getter) {
   if (storage_policy_.get() && storage_policy_->HasSessionOnlyOrigins()) {
     storage_partition->GetDOMStorageContext()->GetLocalStorageUsage(
         base::Bind(&SessionDataDeleter::ClearSessionOnlyLocalStorage,
                    this,
                    storage_partition));
   }
   content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&SessionDataDeleter::DeleteSessionCookiesOnIOThread,
-                 this,
-                 profile_io_data));
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&SessionDataDeleter::DeleteSessionCookiesOnIOThread, this,
+                 url_request_context_getter));

[sky, 2016/03/03 00:58:56]

Is URLRequestContextGetter thread safe?

[mmenke, 2016/03/03 01:14:40]

It's refcounted.

 }
 
 SessionDataDeleter::~SessionDataDeleter() {}
 
 void SessionDataDeleter::ClearSessionOnlyLocalStorage(
     content::StoragePartition* storage_partition,
     const std::vector<content::LocalStorageUsageInfo>& usages) {
   DCHECK(storage_policy_.get());
   DCHECK(storage_policy_->HasSessionOnlyOrigins());
   for (size_t i = 0; i < usages.size(); ++i) {
     const content::LocalStorageUsageInfo& usage = usages[i];
     if (!storage_policy_->IsStorageSessionOnly(usage.origin))
       continue;
     storage_partition->GetDOMStorageContext()->DeleteLocalStorage(usage.origin);
   }
 }
 
 void SessionDataDeleter::DeleteSessionCookiesOnIOThread(
-    ProfileIOData* profile_io_data) {
+    scoped_refptr<net::URLRequestContextGetter> url_request_context_getter) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   net::URLRequestContext* request_context =
-      profile_io_data->GetMainRequestContext();
-  cookie_store_ = request_context->cookie_store();
+      url_request_context_getter->GetURLRequestContext();
+  // Shouldn't happen, but best not to depend on the URLRequestContext's

[sky, 2016/03/03 00:58:56]

I don't understand this comment. Either it can return null, or it can't. You're
implying you don't know.
Also, the description for GetURLRequestContext() says "Must only be called on
the network task runner., yet this is running on the io thread.

[mmenke, 2016/03/03 01:14:40]

It can, but only if ProfileIOData has been destroyed on the IO thread.  The task
to do this is posted to the IO thread by the ProfileIOData's destructor. 
SessionDataDeleter::Run is most likely not called after the Profile has been
destroyed, or in the Profile's destructor.  I don't want to depend on that.
The IO thread is a content/ layer concept.  Net is below content, and an
instance network stack can be set up on any single thread (Well...modulo a
couple globals that should be fixed).

The IO thread is the thread the main network stack runs on.

+  // lifetime
+  if (!request_context)
+    return;
+  net::CookieStore* cookie_store = request_context->cookie_store();
+  // If these callbacks are invoked, |cookie_store| is guaranteed to still
+  // exist, since deleting the CookieStore will cancel pending callbacks.
   if (delete_only_by_session_only_policy_) {
-    cookie_store_->GetAllCookiesAsync(
-        base::Bind(&SessionDataDeleter::DeleteSessionOnlyOriginCookies, this));
+    cookie_store->GetAllCookiesAsync(
+        base::Bind(&SessionDataDeleter::DeleteSessionOnlyOriginCookies, this,
+                   base::Unretained(cookie_store)));
   } else {
-    cookie_store_->DeleteSessionCookiesAsync(
-        base::Bind(&SessionDataDeleter::DeleteSessionCookiesDone, this));
+    cookie_store->DeleteSessionCookiesAsync(
+        base::Bind(&SessionDataDeleter::DeleteSessionCookiesDone, this,
+                   base::Unretained(cookie_store)));
   }
 }
 
-void SessionDataDeleter::DeleteSessionCookiesDone(int num_deleted) {
-  cookie_store_->GetAllCookiesAsync(
-      base::Bind(&SessionDataDeleter::DeleteSessionOnlyOriginCookies, this));
+void SessionDataDeleter::DeleteSessionCookiesDone(
+    net::CookieStore* cookie_store,
+    int num_deleted) {
+  // If these callbacks are invoked, |cookie_store| is gauranteed to still
+  // exist, since deleting the CookieStore will cancel pending callbacks.
+  cookie_store->GetAllCookiesAsync(
+      base::Bind(&SessionDataDeleter::DeleteSessionOnlyOriginCookies, this,
+                 base::Unretained(cookie_store)));
 }
 
 void SessionDataDeleter::DeleteSessionOnlyOriginCookies(
+    net::CookieStore* cookie_store,
     const net::CookieList& cookies) {
   if (!storage_policy_.get() || !storage_policy_->HasSessionOnlyOrigins())
     return;
 
-  for (net::CookieList::const_iterator it = cookies.begin();
-       it != cookies.end();
-       ++it) {
+  for (const auto& cookie : cookies) {
     GURL url =
-        net::cookie_util::CookieOriginToURL(it->Domain(), it->IsSecure());
+        net::cookie_util::CookieOriginToURL(cookie.Domain(), cookie.IsSecure());
     if (!storage_policy_->IsStorageSessionOnly(url))
       continue;
-    cookie_store_->DeleteCanonicalCookieAsync(*it, base::Bind(CookieDeleted));
+    cookie_store->DeleteCanonicalCookieAsync(cookie, base::Bind(CookieDeleted));
   }
 }
 
 }  // namespace
 
 void DeleteSessionOnlyData(Profile* profile) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (browser_shutdown::IsTryingToQuit())
     return;
 
   // TODO: Remove Athena special casing once the AthenaSessionRestore is in
   // place.
 #if defined(OS_ANDROID)
   SessionStartupPref::Type startup_pref_type =
       SessionStartupPref::GetDefaultStartupType();
 #else
   SessionStartupPref::Type startup_pref_type =
       StartupBrowserCreator::GetSessionStartupPref(
           *base::CommandLine::ForCurrentProcess(), profile).type;
 #endif
 
   scoped_refptr<SessionDataDeleter> deleter(
       new SessionDataDeleter(profile->GetSpecialStoragePolicy(),
                              startup_pref_type == SessionStartupPref::LAST));
-  deleter->Run(
-      Profile::GetDefaultStoragePartition(profile),
-      ProfileIOData::FromResourceContext(profile->GetResourceContext()));
+  deleter->Run(Profile::GetDefaultStoragePartition(profile),
+               profile->GetRequestContext());
 }