Make NotificationService an interface in the content namespace, and switch callers to use it. Mov...

chrome/browser/component_updater/component_updater_service.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/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_unpacker.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/browser/utility_process_host.h"
 #include "content/common/net/url_fetcher.h"
-#include "content/common/notification_service.h"
+#include "content/public/browser/notification_service.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 
 namespace {
 // Extends an omaha compatible update check url |query| string. Does
 // not mutate the string if it would be longer than |limit| chars.
 bool AddQueryString(std::string id, std::string version,
                     size_t limit, std::string* query) {
   std::string additional =
@@ skipping 301 matching lines @@
 }
 
 ComponentUpdateService::Status CrxUpdateService::Start() {
   // Note that RegisterComponent will call Start() when the first
   // component is registered, so it can be called twice. This way
   // we avoid scheduling the timer if there is no work to do.
   running_ = true;
   if (work_items_.empty())
     return kOk;
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_COMPONENT_UPDATER_STARTED,
     content::Source<ComponentUpdateService>(this),
-    NotificationService::NoDetails());
+    content::NotificationService::NoDetails());
 
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(config_->InitialDelay()),
                this, &CrxUpdateService::ProcessPendingItems);
   return kOk;
 }
 
 // Stop the main check + update loop. In flight operations will be
 // completed.
 ComponentUpdateService::Status CrxUpdateService::Stop() {
   running_ = false;
@@ skipping 10 matching lines @@
   CHECK(!timer_.IsRunning());
   // It could be the case that Stop() had been called while a url request
   // or unpacking was in flight, if so we arrive here but |running_| is
   // false. In that case do not loop again.
   if (!running_)
     return;
 
   int64 delay = step_delay ? config_->StepDelay() : config_->NextCheckDelay();
 
   if (!step_delay) {
-    NotificationService::current()->Notify(
+    content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING,
         content::Source<ComponentUpdateService>(this),
-        NotificationService::NoDetails());
+        content::NotificationService::NoDetails());
     // Zero is only used for unit tests.
     if (0 == delay)
       return;
   }
 
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(delay),
                this, &CrxUpdateService::ProcessPendingItems);
 }
 
 // Given a extension-like component id, find the associated component.
@@ skipping 229 matching lines @@
         continue;
       }
     }
     // All test passed. Queue an upgrade for this component and fire the
     // notifications.
     crx->crx_url = it->crx_url;
     crx->status = CrxUpdateItem::kCanUpdate;
     crx->next_version = Version(it->version);
     ++update_pending;
 
-    NotificationService::current()->Notify(
+    content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATE_FOUND,
         content::Source<std::string>(&crx->id),
-        NotificationService::NoDetails());
+        content::NotificationService::NoDetails());
   }
 
   // All the components that are not mentioned in the manifest we
   // consider them up to date.
   ChangeItemStatus(CrxUpdateItem::kChecking, CrxUpdateItem::kUpToDate);
 
   // If there are updates pending we do a short wait.
   ScheduleNextRun(update_pending ? true : false);
 }
 
@@ skipping 23 matching lines @@
     url_fetcher_.reset();
     ScheduleNextRun(false);
   } else {
     FilePath temp_crx_path;
     CHECK(source->GetResponseAsFilePath(true, &temp_crx_path));
     size_t count = ChangeItemStatus(CrxUpdateItem::kDownloading,
                                     CrxUpdateItem::kUpdating);
     DCHECK_EQ(count, 1ul);
     url_fetcher_.reset();
 
-    NotificationService::current()->Notify(
+    content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATE_READY,
         content::Source<std::string>(&context->id),
-        NotificationService::NoDetails());
+        content::NotificationService::NoDetails());
 
     BrowserThread::PostDelayedTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(this, &CrxUpdateService::Install,
                           context,
                           temp_crx_path),
         config_->StepDelay());
   }
 }
 
 // Install consists of digital signature verification, unpacking and then
@@ skipping 45 matching lines @@
   ScheduleNextRun(false);
 }
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(
     ComponentUpdateService::Configurator* config) {
   DCHECK(config);
   return new CrxUpdateService(config);
 }