Remove deprecated chrome.pageActions api functions

chrome/browser/extensions/api/extension_action/extension_action_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.
 
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 
 #include "base/base64.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 54 matching lines @@
   ACTIVE = 2,
 };
 
 // Whether the browser action is visible in the toolbar.
 const char kBrowserActionVisible[] = "browser_action_visible";
 
 // Errors.
 const char kNoExtensionActionError[] =
     "This extension has no action specified.";
 const char kNoTabError[] = "No tab with id: *.";
-const char kNoPageActionError[] =
-    "This extension has no page action specified.";
-const char kUrlNotActiveError[] = "This url is no longer active: *.";
 const char kOpenPopupError[] =
     "Failed to show popup either because there is an existing popup or another "
     "error occurred.";
 const char kInternalError[] = "Internal error.";
 
 struct IconRepresentationInfo {
   // Size as a string that will be used to retrieve representation value from
   // SetIcon function arguments.
   const char* size_string;
   // Scale factor for which the represantion should be used.
@@ skipping 164 matching lines @@
   registry->RegisterFunction<BrowserActionSetPopupFunction>();
   registry->RegisterFunction<BrowserActionGetTitleFunction>();
   registry->RegisterFunction<BrowserActionGetBadgeTextFunction>();
   registry->RegisterFunction<BrowserActionGetBadgeBackgroundColorFunction>();
   registry->RegisterFunction<BrowserActionGetPopupFunction>();
   registry->RegisterFunction<BrowserActionEnableFunction>();
   registry->RegisterFunction<BrowserActionDisableFunction>();
   registry->RegisterFunction<BrowserActionOpenPopupFunction>();
 
   // Page Actions
-  registry->RegisterFunction<EnablePageActionsFunction>();
-  registry->RegisterFunction<DisablePageActionsFunction>();
   registry->RegisterFunction<PageActionShowFunction>();
   registry->RegisterFunction<PageActionHideFunction>();
   registry->RegisterFunction<PageActionSetIconFunction>();
   registry->RegisterFunction<PageActionSetTitleFunction>();
   registry->RegisterFunction<PageActionSetPopupFunction>();
   registry->RegisterFunction<PageActionGetTitleFunction>();
   registry->RegisterFunction<PageActionGetPopupFunction>();
 }
 
 ExtensionActionAPI::~ExtensionActionAPI() {
@@ skipping 28 matching lines @@
     ExtensionPrefs* prefs,
     const std::string& extension_id,
     bool visible) {
   if (GetBrowserActionVisibility(prefs, extension_id) == visible)
     return;
 
   prefs->UpdateExtensionPref(extension_id,
                              kBrowserActionVisible,
                              new base::FundamentalValue(visible));
   content::NotificationService::current()->Notify(
-      extensions::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
+      NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
       content::Source<ExtensionPrefs>(prefs),
       content::Details<const std::string>(&extension_id));
 }
 
 // static
 void ExtensionActionAPI::BrowserActionExecuted(
     content::BrowserContext* context,
     const ExtensionAction& browser_action,
     WebContents* web_contents) {
   ExtensionActionExecuted(context, browser_action, web_contents);
 }
 
 // static
 void ExtensionActionAPI::PageActionExecuted(content::BrowserContext* context,
                                             const ExtensionAction& page_action,
                                             int tab_id,
                                             const std::string& url,
                                             int button) {
   DispatchOldPageActionEvent(context,
                              page_action.extension_id(),
                              page_action.id(),
                              tab_id,
                              url,
                              button);
   WebContents* web_contents = NULL;
-  if (!extensions::ExtensionTabUtil::GetTabById(
+  if (!ExtensionTabUtil::GetTabById(
            tab_id,
            Profile::FromBrowserContext(context),
            context->IsOffTheRecord(),
            NULL,
            NULL,
            &web_contents,
            NULL)) {
     return;
   }
   ExtensionActionExecuted(context, page_action, web_contents);
 }
 
 // static
 void ExtensionActionAPI::DispatchEventToExtension(
     content::BrowserContext* context,
     const std::string& extension_id,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
-  if (!extensions::EventRouter::Get(context))
+  if (!EventRouter::Get(context))
     return;
 
   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
   event->restrict_to_browser_context = context;
   event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
   EventRouter::Get(context)
       ->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 // static
@@ skipping 31 matching lines @@
       event_name = "pageAction.onClicked";
       break;
     case ActionInfo::TYPE_SYSTEM_INDICATOR:
       // The System Indicator handles its own clicks.
       break;
   }
 
   if (event_name) {
     scoped_ptr<base::ListValue> args(new base::ListValue());
     base::DictionaryValue* tab_value =
-        extensions::ExtensionTabUtil::CreateTabValue(web_contents);
+        ExtensionTabUtil::CreateTabValue(web_contents);
     args->Append(tab_value);
 
     DispatchEventToExtension(
         context, extension_action.extension_id(), event_name, args.Pass());
   }
 }
 
 void ExtensionActionAPI::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 36 matching lines @@
 }
 
 //
 // ExtensionActionStorageManager
 //
 
 ExtensionActionStorageManager::ExtensionActionStorageManager(Profile* profile)
     : profile_(profile), extension_registry_observer_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
   registrar_.Add(this,
-                 extensions::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
+                 NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
   StateStore* storage = ExtensionSystem::Get(profile_)->state_store();
   if (storage)
     storage->RegisterKey(kBrowserActionStorageKey);
 }
 
 ExtensionActionStorageManager::~ExtensionActionStorageManager() {
 }
 
@@ skipping 12 matching lines @@
         base::Bind(&ExtensionActionStorageManager::ReadFromStorage,
                    AsWeakPtr(),
                    extension->id()));
   }
 }
 
 void ExtensionActionStorageManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK_EQ(type, extensions::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED);
+  DCHECK_EQ(type, NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED);
   ExtensionAction* extension_action =
       content::Source<ExtensionAction>(source).ptr();
   Profile* profile = content::Details<Profile>(details).ptr();
   if (profile != profile_)
     return;
 
   WriteToStorage(extension_action);
 }
 
 void ExtensionActionStorageManager::WriteToStorage(
@@ skipping 301 matching lines @@
     error_ = kInternalError;
     return false;
   }
 
   if (!model->ShowBrowserActionPopup(extension_)) {
     error_ = kOpenPopupError;
     return false;
   }
 
   registrar_.Add(this,
-                 extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
+                 NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
                  content::Source<Profile>(GetProfile()));
 
   // Set a timeout for waiting for the notification that the popup is loaded.
   // Waiting is required so that the popup view can be retrieved by the custom
   // bindings for the response callback. It's also needed to keep this function
   // instance around until a notification is observed.
   base::MessageLoopForUI::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&BrowserActionOpenPopupFunction::OpenPopupTimedOut, this),
       base::TimeDelta::FromSeconds(10));
   return true;
 }
 
 void BrowserActionOpenPopupFunction::OpenPopupTimedOut() {
   if (response_sent_)
     return;
 
   DVLOG(1) << "chrome.browserAction.openPopup did not show a popup.";
   error_ = kOpenPopupError;
   SendResponse(false);
   response_sent_ = true;
 }
 
 void BrowserActionOpenPopupFunction::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK_EQ(extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING, type);
+  DCHECK_EQ(NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING, type);
   if (response_sent_)
     return;
 
   ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
   if (host->extension_host_type() != VIEW_TYPE_EXTENSION_POPUP ||
       host->extension()->id() != extension_->id())
     return;
 
   SendResponse(true);
   response_sent_ = true;
   registrar_.RemoveAll();
 }
 
 }  // namespace extensions
-
-//
-// PageActionsFunction (deprecated)
-//
-
-PageActionsFunction::PageActionsFunction() {
-}
-
-PageActionsFunction::~PageActionsFunction() {
-}
-
-bool PageActionsFunction::SetPageActionEnabled(bool enable) {
-  std::string extension_action_id;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_action_id));
-  base::DictionaryValue* action = NULL;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &action));
-
-  int tab_id;
-  EXTENSION_FUNCTION_VALIDATE(action->GetInteger(
-      page_actions_keys::kTabIdKey, &tab_id));
-  std::string url;
-  EXTENSION_FUNCTION_VALIDATE(action->GetString(
-      page_actions_keys::kUrlKey, &url));
-
-  std::string title;
-  if (enable) {
-    if (action->HasKey(page_actions_keys::kTitleKey))
-      EXTENSION_FUNCTION_VALIDATE(action->GetString(
-          page_actions_keys::kTitleKey, &title));
-  }
-
-  ExtensionAction* page_action = extensions::ExtensionActionManager::Get(
-                                     GetProfile())->GetPageAction(*extension());
-  if (!page_action) {
-    error_ = extensions::kNoPageActionError;
-    return false;
-  }
-
-  // Find the WebContents that contains this tab id.
-  WebContents* contents = NULL;
-  bool result = extensions::ExtensionTabUtil::GetTabById(
-      tab_id, GetProfile(), include_incognito(), NULL, NULL, &contents, NULL);
-  if (!result || !contents) {
-    error_ = extensions::ErrorUtils::FormatErrorMessage(
-        extensions::kNoTabError, base::IntToString(tab_id));
-    return false;
-  }
-
-  // Make sure the URL hasn't changed.
-  content::NavigationEntry* entry = contents->GetController().GetVisibleEntry();
-  if (!entry || url != entry->GetURL().spec()) {
-    error_ = extensions::ErrorUtils::FormatErrorMessage(
-        extensions::kUrlNotActiveError, url);
-    return false;
-  }
-
-  // Set visibility and broadcast notifications that the UI should be updated.
-  page_action->SetIsVisible(tab_id, enable);
-  page_action->SetTitle(tab_id, title);
-  extensions::LocationBarController::NotifyChange(contents);
-
-  return true;
-}
-
-bool EnablePageActionsFunction::RunSync() {
-  return SetPageActionEnabled(true);
-}
-
-bool DisablePageActionsFunction::RunSync() {
-  return SetPageActionEnabled(false);
-}