Moving notification types which are chrome specific to a new header file chrome_notification_type...

chrome/browser/extensions/user_script_master.cc

 // Copyright (c) 2011 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/user_script_master.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/pickle.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/common/notification_service.h"
 
 // Helper function to parse greasesmonkey headers
 static bool GetDeclarationValue(const base::StringPiece& line,
                                 const base::StringPiece& prefix,
                                 std::string* value) {
@@ skipping 214 matching lines @@
       master_thread_id_, FROM_HERE,
       NewRunnableMethod(
           this, &ScriptReloader::NotifyMaster, Serialize(user_scripts)));
 }
 
 
 UserScriptMaster::UserScriptMaster(Profile* profile)
     : extensions_service_ready_(false),
       pending_load_(false),
       profile_(profile) {
-  registrar_.Add(this, NotificationType::EXTENSIONS_READY,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
                  Source<Profile>(profile_));
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  Source<Profile>(profile_));
-  registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  Source<Profile>(profile_));
-  registrar_.Add(this, NotificationType::RENDERER_PROCESS_CREATED,
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  NotificationService::AllSources());
 }
 
 UserScriptMaster::~UserScriptMaster() {
   if (script_reloader_)
     script_reloader_->DisownMaster();
 }
 
 void UserScriptMaster::NewScriptsAvailable(base::SharedMemory* handle) {
   // Ensure handle is deleted or released.
   scoped_ptr<base::SharedMemory> handle_deleter(handle);
 
   if (pending_load_) {
     // While we were loading, there were further changes.  Don't bother
     // notifying about these scripts and instead just immediately reload.
     pending_load_ = false;
     StartLoad();
   } else {
     // We're no longer loading.
     script_reloader_ = NULL;
     // We've got scripts ready to go.
     shared_memory_.swap(handle_deleter);
 
     for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
          !i.IsAtEnd(); i.Advance()) {
       SendUpdate(i.GetCurrentValue(), handle);
     }
 
     NotificationService::current()->Notify(
-        NotificationType::USER_SCRIPTS_UPDATED,
+        chrome::NOTIFICATION_USER_SCRIPTS_UPDATED,
         Source<Profile>(profile_),
         Details<base::SharedMemory>(handle));
   }
 }
 
-void UserScriptMaster::Observe(NotificationType type,
+void UserScriptMaster::Observe(int type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
   bool should_start_load = false;
-  switch (type.value) {
-    case NotificationType::EXTENSIONS_READY:
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSIONS_READY:
       extensions_service_ready_ = true;
       should_start_load = true;
       break;
-    case NotificationType::EXTENSION_LOADED: {
+    case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Add any content scripts inside the extension.
       const Extension* extension = Details<const Extension>(details).ptr();
       bool incognito_enabled = profile_->GetExtensionService()->
           IsIncognitoEnabled(extension->id());
       const UserScriptList& scripts = extension->content_scripts();
       for (UserScriptList::const_iterator iter = scripts.begin();
            iter != scripts.end(); ++iter) {
         user_scripts_.push_back(*iter);
         user_scripts_.back().set_incognito_enabled(incognito_enabled);
       }
       if (extensions_service_ready_)
         should_start_load = true;
       break;
     }
-    case NotificationType::EXTENSION_UNLOADED: {
+    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       // Remove any content scripts.
       const Extension* extension =
           Details<UnloadedExtensionInfo>(details)->extension;
       UserScriptList new_user_scripts;
       for (UserScriptList::iterator iter = user_scripts_.begin();
            iter != user_scripts_.end(); ++iter) {
         if (iter->extension_id() != extension->id())
           new_user_scripts.push_back(*iter);
       }
       user_scripts_ = new_user_scripts;
       should_start_load = true;
 
       // TODO(aa): Do we want to do something smarter for the scripts that have
       // already been injected?
 
       break;
     }
-    case NotificationType::RENDERER_PROCESS_CREATED: {
+    case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
       RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
       if (ScriptsReady())
         SendUpdate(process, GetSharedMemory());
       break;
     }
     default:
       DCHECK(false);
   }
 
   if (should_start_load) {
@@ skipping 24 matching lines @@
   if (!handle)
     return;
 
   base::SharedMemoryHandle handle_for_process;
   if (!shared_memory->ShareToProcess(handle, &handle_for_process))
     return;  // This can legitimately fail if the renderer asserts at startup.
 
   if (base::SharedMemory::IsHandleValid(handle_for_process))
     process->Send(new ExtensionMsg_UpdateUserScripts(handle_for_process));
 }