Cleanup: Simplify some extension API code.

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>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/cookies/cookies_api_constants.h"
 #include "chrome/browser/extensions/api/cookies/cookies_helpers.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/api/cookies.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 30 matching lines @@
   registrar_.Add(this,
                  chrome::NOTIFICATION_COOKIE_CHANGED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 void ExtensionCookiesEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   Profile* profile = content::Source<Profile>(source).ptr();
-  if (!profile_->IsSameProfile(profile)) {
+  if (!profile_->IsSameProfile(profile))
     return;
-  }
+
   switch (type) {
     case chrome::NOTIFICATION_COOKIE_CHANGED:
       CookieChanged(
           profile,
           content::Details<ChromeCookieDetails>(details).ptr());
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void ExtensionCookiesEventRouter::CookieChanged(
     Profile* profile,
     ChromeCookieDetails* details) {
   scoped_ptr<ListValue> args(new ListValue());
   DictionaryValue* dict = new DictionaryValue();
   dict->SetBoolean(keys::kRemovedKey, details->removed);
 
   scoped_ptr<Cookie> cookie(
       cookies_helpers::CreateCookie(*details->cookie,
-          cookies_helpers::GetStoreIdFromProfile(profile)));
+          cookies_helpers::GetStoreIdFromProfile(profile_)));
   dict->Set(keys::kCookieKey, cookie->ToValue().release());
 
-  // Map the interal cause to an external string.
+  // Map the internal cause to an external string.
   std::string cause;
   switch (details->cause) {
     case net::CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT:
       cause = keys::kExplicitChangeCause;
       break;
 
     case net::CookieMonster::Delegate::CHANGE_COOKIE_OVERWRITE:
       cause = keys::kOverwriteChangeCause;
       break;
 
@@ skipping 15 matching lines @@
   dict->SetString(keys::kCauseKey, cause);
 
   args->Append(dict);
 
   GURL cookie_domain =
       cookies_helpers::GetURLFromCanonicalCookie(*details->cookie);
   DispatchEvent(profile, keys::kOnChanged, args.Pass(), cookie_domain);
 }
 
 void ExtensionCookiesEventRouter::DispatchEvent(
-    Profile* profile, const char* event_name, scoped_ptr<ListValue> event_args,
+    Profile* profile,
+    const std::string& event_name,
+    scoped_ptr<ListValue> event_args,
     GURL& cookie_domain) {
-  if (profile && profile->GetExtensionEventRouter()) {
-    profile->GetExtensionEventRouter()->DispatchEventToRenderers(
-        event_name, event_args.Pass(), profile, cookie_domain,
-        EventFilteringInfo());
-  }
+  EventRouter* router = profile ? profile->GetExtensionEventRouter() : NULL;
+  if (!router)
+    return;
+  router->DispatchEventToRenderers(event_name, event_args.Pass(), profile,
+                                   cookie_domain);
 }
 
 bool CookiesFunction::ParseUrl(const std::string& url_string, GURL* url,
                                bool check_host_permissions) {
   *url = GURL(url_string);
   if (!url->is_valid()) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kInvalidUrlError, url_string);
     return false;
   }
   // Check against host permissions if needed.
-  if (check_host_permissions &&
-      !GetExtension()->HasHostPermission(*url)) {
+  if (check_host_permissions && !GetExtension()->HasHostPermission(*url)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kNoHostPermissionsError, url->spec());
     return false;
   }
   return true;
 }
 
 bool CookiesFunction::ParseStoreContext(
     std::string* store_id,
     net::URLRequestContextGetter** context) {
@@ skipping 102 matching lines @@
 GetAllCookiesFunction::GetAllCookiesFunction() {
 }
 
 GetAllCookiesFunction::~GetAllCookiesFunction() {
 }
 
 bool GetAllCookiesFunction::RunImpl() {
   parsed_args_ = GetAll::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
-  if (parsed_args_->details.url.get()) {
-    if (!ParseUrl(*parsed_args_->details.url, &url_, false))
-      return false;
+  if (parsed_args_->details.url.get() &&
+      !ParseUrl(*parsed_args_->details.url, &url_, false)) {
+    return false;
   }
 
   std::string store_id = parsed_args_->details.store_id.get() ?
       *parsed_args_->details.store_id : "";
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
   store_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
@@ skipping 250 matching lines @@
   }
   results_ = GetAllCookieStores::Results::Create(cookie_stores);
   return true;
 }
 
 void GetAllCookieStoresFunction::Run() {
   SendResponse(RunImpl());
 }
 
 }  // namespace extensions