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

chrome/browser/sync/glue/extension_change_processor.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/sync/glue/extension_change_processor.h"
 
 #include <sstream>
 #include <string>
 
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/extension_sync.h"
 #include "chrome/browser/sync/glue/extension_util.h"
 #include "chrome/browser/sync/protocol/extension_specifics.pb.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 
 namespace browser_sync {
 
 ExtensionChangeProcessor::ExtensionChangeProcessor(
     UnrecoverableErrorHandler* error_handler)
     : ChangeProcessor(error_handler),
       traits_(GetExtensionSyncTraits()),
       profile_(NULL),
       extension_service_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error_handler);
 }
 
 ExtensionChangeProcessor::~ExtensionChangeProcessor() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 // TODO(akalin): We need to make sure events we receive from either
 // the browser or the syncapi are done in order; this is tricky since
 // some events (e.g., extension installation) are done asynchronously.
 
-void ExtensionChangeProcessor::Observe(NotificationType type,
+void ExtensionChangeProcessor::Observe(int type,
                                        const NotificationSource& source,
                                        const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(running());
   DCHECK(profile_);
-  if ((type != NotificationType::EXTENSION_LOADED) &&
-      (type != NotificationType::EXTENSION_UPDATE_DISABLED) &&
-      (type != NotificationType::EXTENSION_UNLOADED)) {
+  if ((type != chrome::NOTIFICATION_EXTENSION_LOADED) &&
+      (type != chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED) &&
+      (type != chrome::NOTIFICATION_EXTENSION_UNLOADED)) {
     LOG(DFATAL) << "Received unexpected notification of type "
-                << type.value;
+                << type;
     return;
   }
 
   // Filter out unhandled extensions first.
   DCHECK_EQ(Source<Profile>(source).ptr(), profile_);
   const Extension& extension =
-      (type == NotificationType::EXTENSION_UNLOADED) ?
+      (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) ?
       *Details<UnloadedExtensionInfo>(details)->extension :
       *Details<const Extension>(details).ptr();
   if (!traits_.is_valid_and_syncable(extension)) {
     return;
   }
 
   const std::string& id = extension.id();
 
   // Then handle extension uninstalls.
-  if (type == NotificationType::EXTENSION_UNLOADED) {
+  if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
     const UnloadedExtensionInfo& info =
         *Details<UnloadedExtensionInfo>(details).ptr();
     if (info.reason == UnloadedExtensionInfo::UNINSTALL) {
       VLOG(1) << "Removing server data for uninstalled extension " << id
               << " of type " << info.extension->GetType();
       RemoveServerData(traits_, id, share_handle());
       return;
     }
   }
 
   VLOG(1) << "Updating server data for extension " << id
-          << " (notification type = " << type.value << ")";
+          << " (notification type = " << type << ")";
   std::string error;
   if (!UpdateServerData(traits_, extension, *extension_service_,
                         share_handle(), &error)) {
     error_handler()->OnUnrecoverableError(FROM_HERE, error);
   }
 }
 
 void ExtensionChangeProcessor::ApplyChangesFromSyncModel(
     const sync_api::BaseTransaction* trans,
     const sync_api::SyncManager::ChangeRecord* changes,
@@ skipping 64 matching lines @@
   StopObserving();
   profile_ = NULL;
   extension_service_ = NULL;
 }
 
 void ExtensionChangeProcessor::StartObserving() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile_);
 
   notification_registrar_.Add(
-      this, NotificationType::EXTENSION_LOADED,
+      this, chrome::NOTIFICATION_EXTENSION_LOADED,
       Source<Profile>(profile_));
   // Despite the name, this notification is exactly like
   // EXTENSION_LOADED but with an initial state of DISABLED.
   notification_registrar_.Add(
-      this, NotificationType::EXTENSION_UPDATE_DISABLED,
+      this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
       Source<Profile>(profile_));
 
   notification_registrar_.Add(
-      this, NotificationType::EXTENSION_UNLOADED,
+      this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
       Source<Profile>(profile_));
 }
 
 void ExtensionChangeProcessor::StopObserving() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile_);
   VLOG(1) << "Unobserving all notifications";
   notification_registrar_.RemoveAll();
 }
 
 }  // namespace browser_sync