Move ProfileKeyedAPI implementations to take BrowserContext in the constructor (part 1).

chrome/browser/extensions/api/cookies/cookies_api.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 the Chrome Extensions Cookies API.
 
 #include "chrome/browser/extensions/api/cookies/cookies_api.h"
 
 #include <vector>
 
@@ skipping 31 matching lines @@
 namespace Get = extensions::api::cookies::Get;
 namespace GetAll = extensions::api::cookies::GetAll;
 namespace GetAllCookieStores = extensions::api::cookies::GetAllCookieStores;
 namespace Remove = extensions::api::cookies::Remove;
 namespace Set = extensions::api::cookies::Set;
 
 namespace extensions {
 namespace cookies = api::cookies;
 namespace keys = cookies_api_constants;
 
-CookiesEventRouter::CookiesEventRouter(Profile* profile)
-    : profile_(profile) {
+CookiesEventRouter::CookiesEventRouter(content::BrowserContext* context)
+    : profile_(Profile::FromBrowserContext(context)) {
   CHECK(registrar_.IsEmpty());
   registrar_.Add(this,
                  chrome::NOTIFICATION_COOKIE_CHANGED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 CookiesEventRouter::~CookiesEventRouter() {
 }
 
 void CookiesEventRouter::Observe(
@@ skipping 59 matching lines @@
   args->Append(dict);
 
   GURL cookie_domain =
       cookies_helpers::GetURLFromCanonicalCookie(*details->cookie);
   DispatchEvent(profile,
                 cookies::OnChanged::kEventName,
                 args.Pass(),
                 cookie_domain);
 }
 
-void CookiesEventRouter::DispatchEvent(
-    Profile* profile,
-    const std::string& event_name,
-    scoped_ptr<base::ListValue> event_args,
-    GURL& cookie_domain) {
-  EventRouter* router = profile ?
-      extensions::ExtensionSystem::Get(profile)->event_router() : NULL;
+void CookiesEventRouter::DispatchEvent(content::BrowserContext* context,
+                                       const std::string& event_name,
+                                       scoped_ptr<base::ListValue> event_args,
+                                       GURL& cookie_domain) {
+  EventRouter* router =
+      context ? extensions::ExtensionSystem::Get(context)->event_router()
+              : NULL;
   if (!router)
     return;
   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
-  event->restrict_to_browser_context = profile;
+  event->restrict_to_browser_context = context;
   event->event_url = cookie_domain;
   router->BroadcastEvent(event.Pass());
 }
 
 bool CookiesFunction::ParseUrl(const std::string& url_string, GURL* url,
                                bool check_host_permissions) {
   *url = GURL(url_string);
   if (!url->is_valid()) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kInvalidUrlError, url_string);
@@ skipping 55 matching lines @@
   // Read/validate input parameters.
   if (!ParseUrl(parsed_args_->details.url, &url_, true))
     return false;
 
   std::string store_id =
       parsed_args_->details.store_id.get() ? *parsed_args_->details.store_id
                                            : std::string();
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
-  store_context_ = store_context;
+  store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
-  store_context_ = store_context;
+  store_browser_context_ = store_context;
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CookiesGetFunction::GetCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
 void CookiesGetFunction::GetCookieOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::CookieStore* cookie_store =
-      store_context_->GetURLRequestContext()->cookie_store();
+      store_browser_context_->GetURLRequestContext()->cookie_store();
   cookies_helpers::GetCookieListFromStore(
       cookie_store, url_,
       base::Bind(&CookiesGetFunction::GetCookieCallback, this));
 }
 
 void CookiesGetFunction::GetCookieCallback(const net::CookieList& cookie_list) {
   net::CookieList::const_iterator it;
   for (it = cookie_list.begin(); it != cookie_list.end(); ++it) {
     // Return the first matching cookie. Relies on the fact that the
     // CookieMonster returns them in canonical order (longest path, then
@@ skipping 35 matching lines @@
       !ParseUrl(*parsed_args_->details.url, &url_, false)) {
     return false;
   }
 
   std::string store_id =
       parsed_args_->details.store_id.get() ? *parsed_args_->details.store_id
                                            : std::string();
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
-  store_context_ = store_context;
+  store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CookiesGetAllFunction::GetAllCookiesOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
 void CookiesGetAllFunction::GetAllCookiesOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::CookieStore* cookie_store =
-      store_context_->GetURLRequestContext()->cookie_store();
+      store_browser_context_->GetURLRequestContext()->cookie_store();
   cookies_helpers::GetCookieListFromStore(
       cookie_store, url_,
       base::Bind(&CookiesGetAllFunction::GetAllCookiesCallback, this));
 }
 
 void CookiesGetAllFunction::GetAllCookiesCallback(
     const net::CookieList& cookie_list) {
   const extensions::Extension* extension = GetExtension();
   if (extension) {
     std::vector<linked_ptr<Cookie> > match_vector;
@@ skipping 27 matching lines @@
   // Read/validate input parameters.
   if (!ParseUrl(parsed_args_->details.url, &url_, true))
       return false;
 
   std::string store_id =
       parsed_args_->details.store_id.get() ? *parsed_args_->details.store_id
                                            : std::string();
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
-  store_context_ = store_context;
+  store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CookiesSetFunction::SetCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
 void CookiesSetFunction::SetCookieOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::CookieMonster* cookie_monster =
-      store_context_->GetURLRequestContext()->cookie_store()->
-      GetCookieMonster();
+      store_browser_context_->GetURLRequestContext()
+          ->cookie_store()
+          ->GetCookieMonster();
 
   base::Time expiration_time;
   if (parsed_args_->details.expiration_date.get()) {
     // Time::FromDoubleT converts double time 0 to empty Time object. So we need
     // to do special handling here.
     expiration_time = (*parsed_args_->details.expiration_date == 0) ?
         base::Time::UnixEpoch() :
         base::Time::FromDoubleT(*parsed_args_->details.expiration_date);
   }
 
@@ skipping 12 matching lines @@
                                          : false,
       parsed_args_->details.http_only.get() ? *parsed_args_->details.http_only
                                             : false,
       net::COOKIE_PRIORITY_DEFAULT,
       base::Bind(&CookiesSetFunction::PullCookie, this));
 }
 
 void CookiesSetFunction::PullCookie(bool set_cookie_result) {
   // Pull the newly set cookie.
   net::CookieMonster* cookie_monster =
-      store_context_->GetURLRequestContext()->cookie_store()->
-      GetCookieMonster();
+      store_browser_context_->GetURLRequestContext()
+          ->cookie_store()
+          ->GetCookieMonster();
   success_ = set_cookie_result;
   cookies_helpers::GetCookieListFromStore(
       cookie_monster, url_,
       base::Bind(&CookiesSetFunction::PullCookieCallback, this));
 }
 
 void CookiesSetFunction::PullCookieCallback(
     const net::CookieList& cookie_list) {
   net::CookieList::const_iterator it;
   for (it = cookie_list.begin(); it != cookie_list.end(); ++it) {
@@ skipping 41 matching lines @@
   // Read/validate input parameters.
   if (!ParseUrl(parsed_args_->details.url, &url_, true))
     return false;
 
   std::string store_id =
       parsed_args_->details.store_id.get() ? *parsed_args_->details.store_id
                                            : std::string();
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
-  store_context_ = store_context;
+  store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   // Pass the work off to the IO thread.
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CookiesRemoveFunction::RemoveCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will return asynchronously.
   return true;
 }
 
 void CookiesRemoveFunction::RemoveCookieOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Remove the cookie
   net::CookieStore* cookie_store =
-      store_context_->GetURLRequestContext()->cookie_store();
+      store_browser_context_->GetURLRequestContext()->cookie_store();
   cookie_store->DeleteCookieAsync(
       url_, parsed_args_->details.name,
       base::Bind(&CookiesRemoveFunction::RemoveCookieCallback, this));
 }
 
 void CookiesRemoveFunction::RemoveCookieCallback() {
   // Build the callback result
   Remove::Results::Details details;
   details.name = parsed_args_->details.name;
   details.url = url_.spec();
@@ skipping 79 matching lines @@
   return g_factory.Pointer();
 }
 
 void CookiesAPI::OnListenerAdded(
     const extensions::EventListenerInfo& details) {
   cookies_event_router_.reset(new CookiesEventRouter(profile_));
   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
 }
 
 }  // namespace extensions