Remove enable_notifications build flag and define

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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <string>
 
@@ skipping 93 matching lines @@
   PushMessagingBrowserTest() : gcm_service_(nullptr), gcm_driver_(nullptr) {}
   ~PushMessagingBrowserTest() override {}
 
   // InProcessBrowserTest:
   void SetUp() override {
     https_server_.reset(
         new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
     https_server_->ServeFilesFromSourceDirectory("chrome/test/data");
     ASSERT_TRUE(https_server_->Start());
 
-#if defined(ENABLE_NOTIFICATIONS)
     notification_manager_.reset(new StubNotificationUIManager);
-#endif
 
     InProcessBrowserTest::SetUp();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Enable experimental features for subscription restrictions.
     command_line->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
     InProcessBrowserTest::SetUpCommandLine(command_line);
   }
 
   // InProcessBrowserTest:
   void SetUpOnMainThread() override {
     gcm_service_ = static_cast<gcm::FakeGCMProfileService*>(
         gcm::GCMProfileServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             GetBrowser()->profile(), &gcm::FakeGCMProfileService::Build));
     gcm_driver_ = static_cast<instance_id::FakeGCMDriverForInstanceID*>(
         gcm_service_->driver());
 
     push_service_ =
         PushMessagingServiceFactory::GetForProfile(GetBrowser()->profile());
-#if defined(ENABLE_NOTIFICATIONS)
     display_service_.reset(new MessageCenterDisplayService(
         GetBrowser()->profile(), notification_manager_.get()));
     notification_service()->SetNotificationDisplayServiceForTesting(
         display_service_.get());
-#endif
 
     LoadTestPage();
     InProcessBrowserTest::SetUpOnMainThread();
   }
 
   // Calls should be wrapped in the ASSERT_NO_FATAL_FAILURE() macro.
   void RestartPushService() {
     Profile* profile = GetBrowser()->profile();
     PushMessagingServiceFactory::GetInstance()->SetTestingFactory(profile,
                                                                   nullptr);
@@ skipping 13 matching lines @@
     return expectation ==
            KeepAliveRegistry::GetInstance()->IsOriginRegistered(
                KeepAliveOrigin::IN_FLIGHT_PUSH_MESSAGE);
 #else
     return true;
 #endif
   }
 
   // InProcessBrowserTest:
   void TearDown() override {
-#if defined(ENABLE_NOTIFICATIONS)
     notification_service()->SetNotificationDisplayServiceForTesting(nullptr);
-#endif
-
     InProcessBrowserTest::TearDown();
   }
 
   void LoadTestPage(const std::string& path) {
     ui_test_utils::NavigateToURL(GetBrowser(), https_server_->GetURL(path));
   }
 
   void LoadTestPage() { LoadTestPage(GetTestURL()); }
 
   void LoadTestPageWithoutManifest() { LoadTestPage(GetNoManifestTestURL()); }
@@ skipping 42 matching lines @@
 
   PushMessagingAppIdentifier GetAppIdentifierForServiceWorkerRegistration(
       int64_t service_worker_registration_id);
 
   void SendMessageAndWaitUntilHandled(
       const PushMessagingAppIdentifier& app_identifier,
       const gcm::IncomingMessage& message);
 
   net::EmbeddedTestServer* https_server() const { return https_server_.get(); }
 
-#if defined(ENABLE_NOTIFICATIONS)
   // To be called when delivery of a push message has finished. The |run_loop|
   // will be told to quit after |messages_required| messages were received.
   void OnDeliveryFinished(std::vector<size_t>* number_of_notifications_shown,
                           const base::Closure& done_closure) {
     DCHECK(number_of_notifications_shown);
 
     number_of_notifications_shown->push_back(
         notification_manager_->GetNotificationCount());
 
     done_closure.Run();
   }
 
   StubNotificationUIManager* notification_manager() const {
     return notification_manager_.get();
   }
 
   PlatformNotificationServiceImpl* notification_service() const {
     return PlatformNotificationServiceImpl::GetInstance();
   }
-#endif
 
   PushMessagingServiceImpl* push_service() const { return push_service_; }
 
   void SetSiteEngagementScore(const GURL& url, double score) {
     SiteEngagementService* service =
         SiteEngagementService::Get(GetBrowser()->profile());
     service->ResetScoreForURL(url, score);
   }
 
  protected:
   virtual std::string GetTestURL() { return "/push_messaging/test.html"; }
 
   virtual std::string GetNoManifestTestURL() {
     return "/push_messaging/test_no_manifest.html";
   }
 
   virtual Browser* GetBrowser() const { return browser(); }
 
   gcm::FakeGCMProfileService* gcm_service_;
   instance_id::FakeGCMDriverForInstanceID* gcm_driver_;
   base::HistogramTester histogram_tester_;
 
  private:
   std::unique_ptr<net::EmbeddedTestServer> https_server_;
   PushMessagingServiceImpl* push_service_;
 
-#if defined(ENABLE_NOTIFICATIONS)
   std::unique_ptr<StubNotificationUIManager> notification_manager_;
   std::unique_ptr<MessageCenterDisplayService> display_service_;
-#endif
 
   DISALLOW_COPY_AND_ASSIGN(PushMessagingBrowserTest);
 };
 
 void PushMessagingBrowserTest::RequestAndAcceptPermission() {
   std::string script_result;
   GetPermissionRequestManager()->set_auto_response_for_test(
       PermissionRequestManager::ACCEPT_ALL);
   ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
   ASSERT_EQ("permission status - granted", script_result);
@@ skipping 893 matching lines @@
   GURL origin = https_server()->GetURL("/").GetOrigin();
   PushMessagingAppIdentifier app_identifier_afterwards =
       PushMessagingAppIdentifier::FindByServiceWorker(GetBrowser()->profile(),
                                                       origin, 0LL);
   EXPECT_TRUE(app_identifier_afterwards.is_null());
   histogram_tester_.ExpectUniqueSample(
       "PushMessaging.UnregistrationReason",
       content::PUSH_UNREGISTRATION_REASON_DELIVERY_PERMISSION_DENIED, 1);
 }
 
-#if defined(ENABLE_NOTIFICATIONS)
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        PushEventEnforcesUserVisibleNotification) {
   std::string script_result;
 
   ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
@@ skipping 244 matching lines @@
 
   EXPECT_TRUE(IsRegisteredKeepAliveEqualTo(false));
   ASSERT_EQ(1u, notification_manager()->GetNotificationCount());
   EXPECT_EQ("push_test_tag",
             notification_manager()->GetNotificationAt(0).tag());
 
   // Verify that the renderer process hasn't crashed.
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 }
-#endif
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PermissionStateSaysPrompt) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   ASSERT_EQ("permission status - prompt", script_result);
 }
@@ skipping 650 matching lines @@
   ASSERT_NO_FATAL_FAILURE(SubscribeSuccessfully());
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 
   // After dropping the last subscription background mode is still inactive.
   std::string script_result;
   ASSERT_TRUE(RunScript("unsubscribePush()", &script_result));
   EXPECT_EQ("unsubscribe result: true", script_result);
   ASSERT_FALSE(background_mode_manager->IsBackgroundModeActive());
 }
 #endif  // BUILDFLAG(ENABLE_BACKGROUND) && !defined(OS_CHROMEOS)