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

chrome/test/base/ui_test_utils.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/test/base/ui_test_utils.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 28 matching lines @@
 #include "chrome/test/automation/javascript_execution_controller.h"
 #include "chrome/test/base/bookmark_load_observer.h"
 #include "chrome/test/test_navigation_observer.h"
 #include "content/browser/download/download_item.h"
 #include "content/browser/download/download_manager.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/public/browser/notification_service.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/size.h"
 
 #if defined(TOOLKIT_VIEWS)
 #include "views/focus/accelerator_handler.h"
 #endif
@@ skipping 225 matching lines @@
       !tab->render_manager_for_testing()->pending_render_view_host())
     return;
   TestNotificationObserver observer;
   RegisterAndWait(&observer, content::NOTIFICATION_LOAD_STOP,
                   content::Source<NavigationController>(&tab->controller()));
 }
 
 Browser* WaitForNewBrowser() {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
-                  NotificationService::AllSources());
+                   content::NotificationService::AllSources());
   return content::Source<Browser>(observer.source()).ptr();
 }
 
 Browser* WaitForBrowserNotInSet(std::set<Browser*> excluded_browsers) {
   TestNotificationObserver observer;
   Browser* new_browser = GetBrowserNotInSet(excluded_browsers);
   if (new_browser == NULL) {
     new_browser = WaitForNewBrowser();
     // The new browser should never be in |excluded_browsers|.
     DCHECK(!ContainsKey(excluded_browsers, new_browser));
   }
   return new_browser;
 }
 
 void OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Browser::OpenURLOffTheRecord(profile, url);
   Browser* browser = BrowserList::FindTabbedBrowser(
       profile->GetOffTheRecordProfile(), false);
   WaitForNavigations(&browser->GetSelectedTabContents()->controller(), 1);
 }
 
 void NavigateToURL(browser::NavigateParams* params) {
-  TestNavigationObserver observer(NotificationService::AllSources(), NULL, 1);
+  TestNavigationObserver observer(
+      content::NotificationService::AllSources(), NULL, 1);
   browser::Navigate(params);
   observer.WaitForObservation();
 }
 
 void NavigateToURL(Browser* browser, const GURL& url) {
   NavigateToURLWithDisposition(browser, url, CURRENT_TAB,
                                BROWSER_TEST_WAIT_FOR_NAVIGATION);
 }
 
 // Navigates the specified tab (via |disposition|) of |browser| to |url|,
@@ skipping 14 matching lines @@
 
   std::set<Browser*> initial_browsers;
   for (std::vector<Browser*>::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end();
        ++iter) {
     initial_browsers.insert(*iter);
   }
 
   WindowedNotificationObserver tab_added_observer(
       content::NOTIFICATION_TAB_ADDED,
-      NotificationService::AllSources());
+      content::NotificationService::AllSources());
 
   browser->OpenURL(url, GURL(), disposition, content::PAGE_TRANSITION_TYPED);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_BROWSER)
     browser = WaitForBrowserNotInSet(initial_browsers);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_TAB)
     tab_added_observer.Wait();
   if (!(browser_test_flags & BROWSER_TEST_WAIT_FOR_NAVIGATION)) {
     // Some other flag caused the wait prior to this.
     return;
   }
@@ skipping 120 matching lines @@
     GURL::Replacements replacements;
     replacements.SetQueryStr(query_string);
     return url.ReplaceComponents(replacements);
   }
   return url;
 }
 
 AppModalDialog* WaitForAppModalDialog() {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
-                  NotificationService::AllSources());
+                  content::NotificationService::AllSources());
   return content::Source<AppModalDialog>(observer.source()).ptr();
 }
 
 void CrashTab(TabContents* tab) {
   RenderProcessHost* rph = tab->render_view_host()->process();
   base::KillProcess(rph->GetHandle(), 0, false);
   TestNotificationObserver observer;
   RegisterAndWait(&observer, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                   content::Source<RenderProcessHost>(rph));
 }
@@ skipping 44 matching lines @@
   service->Load();
   TemplateURLServiceTestUtil::BlockTillServiceProcessesRequests();
   ASSERT_TRUE(service->loaded());
 }
 
 void WaitForHistoryToLoad(Browser* browser) {
   HistoryService* history_service =
       browser->profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   WindowedNotificationObserver history_loaded_observer(
       chrome::NOTIFICATION_HISTORY_LOADED,
-      NotificationService::AllSources());
+      content::NotificationService::AllSources());
   if (!history_service->BackendLoaded())
     history_loaded_observer.Wait();
 }
 
 bool GetNativeWindow(const Browser* browser, gfx::NativeWindow* native_window) {
   BrowserWindow* window = browser->window();
   if (!window)
     return false;
 
   *native_window = window->GetNativeHandle();
@@ skipping 193 matching lines @@
   cmd_line->AppendArg("--server=stop");
   cmd_line->AppendArg("--chromium");
   cmd_line->AppendArgNative(FILE_PATH_LITERAL("--pidfile=") +
                             websocket_pid_file_.value());
   base::LaunchOptions options;
   options.wait = true;
   base::LaunchProcess(*cmd_line.get(), options, NULL);
 }
 
 TestNotificationObserver::TestNotificationObserver()
-    : source_(NotificationService::AllSources()) {
+    : source_(content::NotificationService::AllSources()) {
 }
 
 TestNotificationObserver::~TestNotificationObserver() {}
 
 void TestNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   source_ = source;
   details_ = details;
   MessageLoopForUI::current()->Quit();
 }
 
 WindowedNotificationObserver::WindowedNotificationObserver(
     int notification_type,
     const content::NotificationSource& source)
     : seen_(false),
       running_(false),
       waiting_for_(source) {
   registrar_.Add(this, notification_type, waiting_for_);
 }
 
 WindowedNotificationObserver::~WindowedNotificationObserver() {}
 
 void WindowedNotificationObserver::Wait() {
-  if (seen_ || (waiting_for_ == NotificationService::AllSources() &&
+  if (seen_ || (waiting_for_ == content::NotificationService::AllSources() &&
                 !sources_seen_.empty())) {
     return;
   }
 
   running_ = true;
   ui_test_utils::RunMessageLoop();
 }
 
 void WindowedNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (waiting_for_ == source ||
-      (running_ && waiting_for_ == NotificationService::AllSources())) {
+      (running_ && waiting_for_ == content::NotificationService::AllSources())) {
     seen_ = true;
     if (running_)
       MessageLoopForUI::current()->Quit();
   } else {
     sources_seen_.insert(source.map_key());
   }
 }
 
 TitleWatcher::TitleWatcher(TabContents* tab_contents,
                            const string16& expected_title)
@@ skipping 53 matching lines @@
   if (it == expected_titles_.end())
     return;
   observed_title_ = *it;
   expected_title_observed_ = true;
   if (quit_loop_on_observation_)
     MessageLoopForUI::current()->Quit();
 }
 
 DOMMessageQueue::DOMMessageQueue() {
   registrar_.Add(this, chrome::NOTIFICATION_DOM_OPERATION_RESPONSE,
-                 NotificationService::AllSources());
+                 content::NotificationService::AllSources());
 }
 
 DOMMessageQueue::~DOMMessageQueue() {}
 
 void DOMMessageQueue::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   content::Details<DomOperationNotificationDetails> dom_op_details(details);
   content::Source<RenderViewHost> sender(source);
   message_queue_.push(dom_op_details->json());
@@ skipping 89 matching lines @@
   return taker.TakeRenderWidgetSnapshot(rwh, page_size, page_size, bitmap);
 }
 
 bool TakeEntirePageSnapshot(RenderViewHost* rvh, SkBitmap* bitmap) {
   DCHECK(bitmap);
   SnapshotTaker taker;
   return taker.TakeEntirePageSnapshot(rvh, bitmap);
 }
 
 }  // namespace ui_test_utils