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

chrome/browser/sync/util/extensions_activity_monitor_unittest.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/util/extensions_activity_monitor.h"
 
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_bookmarks_module.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/browser/browser_thread.h"
-#include "content/common/notification_service.h"
+#include "content/browser/notification_service_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using browser_sync::ExtensionsActivityMonitor;
 namespace keys = extension_manifest_keys;
 
 namespace {
 
 const FilePath::CharType kTestExtensionPath1[] =
 #if defined(OS_POSIX)
     FILE_PATH_LITERAL("/testextension1");
@@ skipping 12 matching lines @@
 const char* kTestExtensionName = "foo extension";
 
 template <class FunctionType>
 class BookmarkAPIEventTask : public Task {
  public:
   BookmarkAPIEventTask(FunctionType* t, Extension* e, size_t repeats,
                        base::WaitableEvent* done) :
        extension_(e), function_(t), repeats_(repeats), done_(done) {}
    virtual void Run() {
      for (size_t i = 0; i < repeats_; i++) {
-       NotificationService::current()->Notify(
+       content::NotificationService::current()->Notify(
            chrome::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
            content::Source<Extension>(extension_.get()),
            content::Details<const BookmarksFunction>(function_.get()));
      }
      done_->Signal();
    }
  private:
   scoped_refptr<Extension> extension_;
   scoped_refptr<FunctionType> function_;
   size_t repeats_;
@@ skipping 24 matching lines @@
     done_event.Wait();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkAPIEventGenerator);
 };
 }  // namespace
 
 class DoUIThreadSetupTask : public Task {
  public:
-  DoUIThreadSetupTask(NotificationService** service,
+  DoUIThreadSetupTask(content::NotificationService** service,
                       base::WaitableEvent* done)
       : service_(service), signal_when_done_(done) {}
   virtual ~DoUIThreadSetupTask() {}
   virtual void Run() {
-    *service_ = new NotificationService();
+    *service_ = new NotificationServiceImpl();
     signal_when_done_->Signal();
   }
  private:
-  NotificationService** service_;
+  content::NotificationService** service_;
   base::WaitableEvent* signal_when_done_;
   DISALLOW_COPY_AND_ASSIGN(DoUIThreadSetupTask);
 };
 
 class ExtensionsActivityMonitorTest : public testing::Test {
  public:
   ExtensionsActivityMonitorTest() : service_(NULL),
       ui_thread_(BrowserThread::UI) { }
   virtual ~ExtensionsActivityMonitorTest() {}
 
@@ skipping 18 matching lines @@
     DictionaryValue input;
     input.SetString(keys::kVersion, kTestExtensionVersion);
     input.SetString(keys::kName, kTestExtensionName);
     scoped_refptr<Extension> extension(Extension::Create(
         FilePath(extension_path), Extension::INVALID, input,
         Extension::STRICT_ERROR_CHECKS, &error));
     EXPECT_EQ("", error);
     return extension->id();
   }
  private:
-  NotificationService* service_;
+  content::NotificationService* service_;
   BrowserThread ui_thread_;
 };
 
 TEST_F(ExtensionsActivityMonitorTest, Basic) {
   ExtensionsActivityMonitor* monitor = new ExtensionsActivityMonitor();
   BookmarkAPIEventGenerator generator;
 
   generator.NewEvent<RemoveBookmarkFunction>(kTestExtensionPath1,
       new RemoveBookmarkFunction(), 1);
   generator.NewEvent<MoveBookmarkFunction>(kTestExtensionPath1,
@@ skipping 87 matching lines @@
 
   generator.NewEvent<CreateBookmarkFunction>(kTestExtensionPath1,
       new CreateBookmarkFunction(), 3);
   monitor->GetAndClearRecords(&results);
 
   EXPECT_EQ(1U, results.size());
   EXPECT_EQ(3U, results[id1].bookmark_write_count);
 
   ui_loop()->DeleteSoon(FROM_HERE, monitor);
 }