Rename (Chrome)SyncExtensionFunction::RunImpl to RunSync so that the RunImpl

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 30 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;
 
+namespace {
+
+bool ParseUrl(ChromeAsyncExtensionFunction* function,
+              const std::string& url_string,
+              GURL* url,
+              bool check_host_permissions) {
+  *url = GURL(url_string);
+  if (!url->is_valid()) {
+    function->SetError(
+        ErrorUtils::FormatErrorMessage(keys::kInvalidUrlError, url_string));
+    return false;
+  }
+  // Check against host permissions if needed.
+  if (check_host_permissions &&
+      !PermissionsData::HasHostPermission(function->GetExtension(), *url)) {
+    function->SetError(ErrorUtils::FormatErrorMessage(
+        keys::kNoHostPermissionsError, url->spec()));
+    return false;
+  }
+  return true;
+}
+
+bool ParseStoreContext(ChromeAsyncExtensionFunction* function,
+                       std::string* store_id,
+                       net::URLRequestContextGetter** context) {
+  DCHECK((context || store_id->empty()));
+  Profile* store_profile = NULL;
+  if (!store_id->empty()) {
+    store_profile = cookies_helpers::ChooseProfileFromStoreId(
+        *store_id, function->GetProfile(), function->include_incognito());
+    if (!store_profile) {
+      function->SetError(ErrorUtils::FormatErrorMessage(
+          keys::kInvalidStoreIdError, *store_id));
+      return false;
+    }
+  } else {
+    // The store ID was not specified; use the current execution context's
+    // cookie store by default.
+    // GetCurrentBrowser() already takes into account incognito settings.
+    Browser* current_browser = function->GetCurrentBrowser();
+    if (!current_browser) {
+      function->SetError(keys::kNoCookieStoreFoundError);
+      return false;
+    }
+    store_profile = current_browser->profile();
+    *store_id = cookies_helpers::GetStoreIdFromProfile(store_profile);
+  }
+
+  if (context)
+    *context = store_profile->GetRequestContext();
+  DCHECK(context);
+
+  return true;
+}
+
+}  // namespace
+
 CookiesEventRouter::CookiesEventRouter(content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)) {
   CHECK(registrar_.IsEmpty());
   registrar_.Add(this,
                  chrome::NOTIFICATION_COOKIE_CHANGED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 CookiesEventRouter::~CookiesEventRouter() {
 }
@@ skipping 74 matching lines @@
                                        GURL& cookie_domain) {
   EventRouter* router = context ? extensions::EventRouter::Get(context) : NULL;
   if (!router)
     return;
   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
   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);
-    return false;
-  }
-  // Check against host permissions if needed.
-  if (check_host_permissions &&
-      !PermissionsData::HasHostPermission(GetExtension(), *url)) {
-    error_ = ErrorUtils::FormatErrorMessage(
-        keys::kNoHostPermissionsError, url->spec());
-    return false;
-  }
-  return true;
-}
-
-bool CookiesFunction::ParseStoreContext(
-    std::string* store_id,
-    net::URLRequestContextGetter** context) {
-  DCHECK((context || store_id->empty()));
-  Profile* store_profile = NULL;
-  if (!store_id->empty()) {
-    store_profile = cookies_helpers::ChooseProfileFromStoreId(
-        *store_id, GetProfile(), include_incognito());
-    if (!store_profile) {
-      error_ = ErrorUtils::FormatErrorMessage(
-          keys::kInvalidStoreIdError, *store_id);
-      return false;
-    }
-  } else {
-    // The store ID was not specified; use the current execution context's
-    // cookie store by default.
-    // GetCurrentBrowser() already takes into account incognito settings.
-    Browser* current_browser = GetCurrentBrowser();
-    if (!current_browser) {
-      error_ = keys::kNoCookieStoreFoundError;
-      return false;
-    }
-    store_profile = current_browser->profile();
-    *store_id = cookies_helpers::GetStoreIdFromProfile(store_profile);
-  }
-
-  if (context)
-    *context = store_profile->GetRequestContext();
-  DCHECK(context);
-
-  return true;
-}
-
 CookiesGetFunction::CookiesGetFunction() {
 }
 
 CookiesGetFunction::~CookiesGetFunction() {
 }
 
 bool CookiesGetFunction::RunImpl() {
   parsed_args_ = Get::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
   // Read/validate input parameters.
-  if (!ParseUrl(parsed_args_->details.url, &url_, true))
+  if (!ParseUrl(this, 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))
+  if (!ParseStoreContext(this, &store_id, &store_context))
     return false;
   store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   store_browser_context_ = store_context;
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CookiesGetFunction::GetCookieOnIOThread, this));
@@ skipping 45 matching lines @@
 }
 
 CookiesGetAllFunction::~CookiesGetAllFunction() {
 }
 
 bool CookiesGetAllFunction::RunImpl() {
   parsed_args_ = GetAll::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
   if (parsed_args_->details.url.get() &&
-      !ParseUrl(*parsed_args_->details.url, &url_, false)) {
+      !ParseUrl(this, *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))
+  if (!ParseStoreContext(this, &store_id, &store_context))
     return false;
   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);
 
@@ skipping 36 matching lines @@
 }
 
 CookiesSetFunction::~CookiesSetFunction() {
 }
 
 bool CookiesSetFunction::RunImpl() {
   parsed_args_ = Set::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
   // Read/validate input parameters.
-  if (!ParseUrl(parsed_args_->details.url, &url_, true))
+  if (!ParseUrl(this, 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))
+  if (!ParseStoreContext(this, &store_id, &store_context))
     return false;
   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);
 
@@ skipping 87 matching lines @@
 }
 
 CookiesRemoveFunction::~CookiesRemoveFunction() {
 }
 
 bool CookiesRemoveFunction::RunImpl() {
   parsed_args_ = Remove::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
   // Read/validate input parameters.
-  if (!ParseUrl(parsed_args_->details.url, &url_, true))
+  if (!ParseUrl(this, 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))
+  if (!ParseStoreContext(this, &store_id, &store_context))
     return false;
   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);
@@ skipping 26 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CookiesRemoveFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
 void CookiesRemoveFunction::RespondOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SendResponse(true);
 }
 
-bool CookiesGetAllCookieStoresFunction::RunImpl() {
+bool CookiesGetAllCookieStoresFunction::RunSync() {
   Profile* original_profile = GetProfile();
   DCHECK(original_profile);
   scoped_ptr<base::ListValue> original_tab_ids(new base::ListValue());
   Profile* incognito_profile = NULL;
   scoped_ptr<base::ListValue> incognito_tab_ids;
   if (include_incognito() && GetProfile()->HasOffTheRecordProfile()) {
     incognito_profile = GetProfile()->GetOffTheRecordProfile();
     if (incognito_profile)
       incognito_tab_ids.reset(new base::ListValue());
   }
@@ skipping 21 matching lines @@
   if (incognito_tab_ids.get() && incognito_tab_ids->GetSize() > 0 &&
       incognito_profile) {
     cookie_stores.push_back(make_linked_ptr(
         cookies_helpers::CreateCookieStore(
             incognito_profile, incognito_tab_ids.release()).release()));
   }
   results_ = GetAllCookieStores::Results::Create(cookie_stores);
   return true;
 }
 
-void CookiesGetAllCookieStoresFunction::Run() {
-  SendResponse(RunImpl());
-}
-
 CookiesAPI::CookiesAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter::Get(browser_context_)
       ->RegisterObserver(this, cookies::OnChanged::kEventName);
 }
 
 CookiesAPI::~CookiesAPI() {
 }
 
 void CookiesAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<CookiesAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<CookiesAPI>* CookiesAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void CookiesAPI::OnListenerAdded(
     const extensions::EventListenerInfo& details) {
   cookies_event_router_.reset(new CookiesEventRouter(browser_context_));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions