Move gcm-independent parts of push messaging out of gcm namespace and directory

chrome/browser/push_messaging/push_messaging_browsertest.cc

 // Copyright 2014 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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/notifications/notification_test_util.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/push_messaging/push_messaging_application_id.h"
+#include "chrome/browser/push_messaging/push_messaging_constants.h"
+#include "chrome/browser/push_messaging/push_messaging_service_factory.h"
 #include "chrome/browser/services/gcm/fake_gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
-#include "chrome/browser/services/gcm/push_messaging_application_id.h"
-#include "chrome/browser/services/gcm/push_messaging_constants.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "components/gcm_driver/gcm_client.h"
 #include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "components/infobars/core/infobar_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "ui/base/window_open_disposition.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
-namespace gcm {
-
 namespace {
 // Responds to a confirm infobar by accepting or cancelling it. Responds to at
 // most one infobar.
 class InfoBarResponder : public infobars::InfoBarManager::Observer {
  public:
   InfoBarResponder(Browser* browser, bool accept)
       : infobar_service_(InfoBarService::FromWebContents(
             browser->tab_strip_model()->GetActiveWebContents())),
         accept_(accept),
         has_observed_(false) {
@@ skipping 128 matching lines @@
             net::BaseTestServer::SSLOptions::CERT_OK),
         base::FilePath(FILE_PATH_LITERAL("chrome/test/data/"))));
     ASSERT_TRUE(https_server_->Start());
 
 #if defined(ENABLE_NOTIFICATIONS)
     notification_manager_.reset(new StubNotificationUIManager);
     notification_service()->SetNotificationUIManagerForTesting(
         notification_manager());
 #endif
 
+    gcm::GCMProfileServiceFactory::SetGlobalTestingFactory(
+        &gcm::FakeGCMProfileService::Build);
+
     InProcessBrowserTest::SetUp();
   }
 
   // InProcessBrowserTest:
   void SetUpOnMainThread() override {
-    gcm_service_ = static_cast<FakeGCMProfileService*>(
-        GCMProfileServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-            browser()->profile(), &FakeGCMProfileService::Build));
+    gcm_service_ = gcm::GCMProfileServiceFactory::GetForProfile(
+        browser()->profile())->AsFakeGCMProfileService();
     gcm_service_->set_collect(true);
+    push_service_ =
+        PushMessagingServiceFactory::GetForProfile(browser()->profile());
 
     LoadTestPage();
 
     InProcessBrowserTest::SetUpOnMainThread();
   }
 
   // InProcessBrowserTest:
   void TearDown() override {
 #if defined(ENABLE_NOTIFICATIONS)
     notification_service()->SetNotificationUIManagerForTesting(nullptr);
@@ skipping 24 matching lines @@
   }
 
   void TryToRegisterSuccessfully(
       const std::string& expected_push_registration_id);
 
   PushMessagingApplicationId GetServiceWorkerAppId(
       int64 service_worker_registration_id);
 
   net::SpawnedTestServer* https_server() const { return https_server_.get(); }
 
-  FakeGCMProfileService* gcm_service() const { return gcm_service_; }
+  gcm::FakeGCMProfileService* gcm_service() const { return gcm_service_; }
 
 #if defined(ENABLE_NOTIFICATIONS)
   StubNotificationUIManager* notification_manager() const {
     return notification_manager_.get();
   }
 
   PlatformNotificationServiceImpl* notification_service() const {
     return PlatformNotificationServiceImpl::GetInstance();
   }
 #endif
 
-  PushMessagingServiceImpl* push_service() {
-    return static_cast<PushMessagingServiceImpl*>(
-        gcm_service_->push_messaging_service());
-  }
+  PushMessagingServiceImpl* push_service() { return push_service_; }
 
  protected:
   virtual std::string GetTestURL() {
     return "files/push_messaging/test.html";
   }
 
  private:
   scoped_ptr<net::SpawnedTestServer> https_server_;
-  FakeGCMProfileService* gcm_service_;
+  gcm::FakeGCMProfileService* gcm_service_;
+  PushMessagingServiceImpl* push_service_;
   scoped_ptr<StubNotificationUIManager> notification_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(PushMessagingBrowserTest);
 };
 
 class PushMessagingBadManifestBrowserTest : public PushMessagingBrowserTest {
   std::string GetTestURL() override {
     return "files/push_messaging/test_bad_manifest.html";
   }
 };
@@ skipping 180 matching lines @@
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
-  GCMClient::IncomingMessage message;
+  gcm::GCMClient::IncomingMessage message;
   message.sender_id = "1234567890";
   message.data["data"] = "testdata";
   push_service()->OnMessage(app_id.app_id_guid(), message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result));
   EXPECT_EQ("testdata", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventNoServiceWorker) {
   if (!IsPushSupported())
     return;
@@ skipping 17 matching lines @@
   // Unregister service worker. Sending a message should now fail.
   ASSERT_TRUE(RunScript("unregisterServiceWorker()", &script_result));
   ASSERT_EQ("service worker unregistration status: true", script_result);
 
   // When the push service will receive it next message, given that there is no
   // SW available, it should unregister |app_id|.
   UnregistrationCallback callback;
   gcm_service()->SetUnregisterCallback(base::Bind(&UnregistrationCallback::Run,
                                                   base::Unretained(&callback)));
 
-  GCMClient::IncomingMessage message;
+  gcm::GCMClient::IncomingMessage message;
   message.sender_id = "1234567890";
   message.data["data"] = "testdata";
   push_service()->OnMessage(app_id.app_id_guid(), message);
 
   callback.WaitUntilSatisfied();
   EXPECT_EQ(app_id.app_id_guid(), callback.app_id());
 
   // No push data should have been received.
   ASSERT_TRUE(RunScript("resultQueue.popImmediately()", &script_result));
   EXPECT_EQ("null", script_result);
@@ skipping 24 matching lines @@
   notification_manager()->CancelAll();
   ASSERT_EQ(0u, notification_manager()->GetNotificationCount());
 
   // We'll need to specify the web_contents in which to eval script, since we're
   // going to run script in a background tab.
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // If the site is visible in an active tab, we should not force a notification
   // to be shown. Try it twice, since we allow one mistake per 10 push events.
-  GCMClient::IncomingMessage message;
+  gcm::GCMClient::IncomingMessage message;
   message.sender_id = "1234567890";
   for (int n = 0; n < 2; n++) {
     message.data["data"] = "testdata";
     push_service()->OnMessage(app_id.app_id_guid(), message);
     ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result));
     EXPECT_EQ("testdata", script_result);
     EXPECT_EQ(0u, notification_manager()->GetNotificationCount());
   }
 
   // Open a blank foreground tab so site is no longer visible.
@@ skipping 70 matching lines @@
 
   LoadTestPage();  // Reload to become controlled.
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("true - is controlled", script_result);
 
   NotificationAddedCallback callback;
   notification_manager()->SetNotificationAddedCallback(
       base::Bind(&NotificationAddedCallback::Run, base::Unretained(&callback)));
 
-  GCMClient::IncomingMessage message;
+  gcm::GCMClient::IncomingMessage message;
   message.sender_id = "1234567890";
   message.data["data"] = "shownotification-without-waituntil";
   push_service()->OnMessage(app_id.app_id_guid(), message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
   EXPECT_EQ("immediate:shownotification-without-waituntil", script_result);
 
   callback.WaitUntilSatisfied();
 
   ASSERT_EQ(1u, notification_manager()->GetNotificationCount());
   EXPECT_EQ(base::ASCIIToUTF16("push_test_tag"),
@@ skipping 60 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, UnregisterSuccess) {
   if (!IsPushSupported())
     return;
 
   std::string script_result;
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
-  gcm_service()->AddExpectedUnregisterResponse(GCMClient::SUCCESS);
+  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
 
   ASSERT_TRUE(RunScript("unregister()", &script_result));
   EXPECT_EQ("unregister result: true", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, UnregisterNetworkError) {
   if (!IsPushSupported())
     return;
 
   std::string script_result;
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
-  gcm_service()->AddExpectedUnregisterResponse(GCMClient::NETWORK_ERROR);
+  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::NETWORK_ERROR);
 
   ASSERT_TRUE(RunScript("unregister()", &script_result));
   EXPECT_EQ("unregister error: NetworkError: "
             "Unregistration failed - could not connect to push server",
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, UnregisterAbortError) {
   if (!IsPushSupported())
     return;
 
   std::string script_result;
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
-  gcm_service()->AddExpectedUnregisterResponse(GCMClient::UNKNOWN_ERROR);
+  gcm_service()->AddExpectedUnregisterResponse(gcm::GCMClient::UNKNOWN_ERROR);
 
   ASSERT_TRUE(RunScript("unregister()", &script_result));
   EXPECT_EQ("unregister error: "
             "AbortError: Unregistration failed - push service error",
             script_result);
 }
 
 #if defined(OS_ANDROID)
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushUnavailableOnAndroidICS) {
   // This test should only run on Android ICS to confirm that the Push API
@@ skipping 238 matching lines @@
   // if the rules it used to have have been reset.
   // The Push service should not unsubcribe |origin| because at no point it was
   // left without permission to use Push.
 
   ASSERT_TRUE(RunScript("hasPermission()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   ASSERT_TRUE(RunScript("hasRegistration()", &script_result));
   EXPECT_EQ("true - registered", script_result);
 }
-
-}  // namespace gcm