Move extension notifications to extensions/browser/notification_types.h

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"
 #include "base/values.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/extension_action/extension_page_actions_api_constants.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/extensions/location_bar_controller.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function_registry.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/image_util.h"
+#include "extensions/browser/notification_types.h"
 #include "extensions/browser/state_store.h"
 #include "extensions/common/error_utils.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 
 using content::WebContents;
 
 namespace page_actions_keys = extension_page_actions_api_constants;
 
@@ skipping 259 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(
-      chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
+      extensions::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);
@@ skipping 91 matching lines @@
   }
 }
 
 //
 // ExtensionActionStorageManager
 //
 
 ExtensionActionStorageManager::ExtensionActionStorageManager(Profile* profile)
     : profile_(profile), extension_registry_observer_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
+  registrar_.Add(this,
+                 extensions::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, chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED);
+  DCHECK_EQ(type, extensions::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 153 matching lines @@
       return;
     case ActionInfo::TYPE_SYSTEM_INDICATOR:
       NotifySystemIndicatorChange();
       return;
   }
   NOTREACHED();
 }
 
 void ExtensionActionFunction::NotifyBrowserActionChange() {
   content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
+      extensions::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
       content::Source<ExtensionAction>(extension_action_),
       content::Details<Profile>(GetProfile()));
 }
 
 void ExtensionActionFunction::NotifyLocationBarChange() {
   LocationBarController::NotifyChange(contents_);
 }
 
 void ExtensionActionFunction::NotifySystemIndicatorChange() {
   content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_EXTENSION_SYSTEM_INDICATOR_UPDATED,
+      extensions::NOTIFICATION_EXTENSION_SYSTEM_INDICATOR_UPDATED,
       content::Source<Profile>(GetProfile()),
       content::Details<ExtensionAction>(extension_action_));
 }
 
 bool ExtensionActionFunction::SetVisible(bool visible) {
   if (extension_action_->GetIsVisible(tab_id_) == visible)
     return true;
   extension_action_->SetIsVisible(tab_id_, visible);
   NotifyChange();
   return true;
@@ skipping 148 matching lines @@
     error_ = kInternalError;
     return false;
   }
 
   if (!model->ShowBrowserActionPopup(extension_)) {
     error_ = kOpenPopupError;
     return false;
   }
 
   registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
+                 extensions::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(chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING, type);
+  DCHECK_EQ(extensions::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;
@@ skipping 65 matching lines @@
   return true;
 }
 
 bool EnablePageActionsFunction::RunSync() {
   return SetPageActionEnabled(true);
 }
 
 bool DisablePageActionsFunction::RunSync() {
   return SetPageActionEnabled(false);
 }