Exceptions for Web Notifications and the Push API by default.

chrome/browser/services/gcm/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"
@@ skipping 14 matching lines @@
 #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())),
@@ skipping 81 matching lines @@
     waiting_ = true;
     while (!done_)
       content::RunMessageLoop();
   }
 
  private:
   bool done_;
   bool waiting_;
 };
 
+// The Push API depends on Web Notifications, which is only available on Android
+// Jelly Bean and later.
+bool IsPushSupported() {
+#if defined(OS_ANDROID)
+  if (base::android::BuildInfo::GetInstance()->sdk_int() <
+      base::android::SDK_VERSION_JELLY_BEAN) {
+    DVLOG(0) << "The Push API is only supported in Android 4.1 and later.";
+    return false;
+  }
+#endif
+  return true;
+}
+
 }  // namespace
 
 class PushMessagingBrowserTest : public InProcessBrowserTest {
  public:
   PushMessagingBrowserTest() : gcm_service_(nullptr) {}
   ~PushMessagingBrowserTest() override {}
 
   // InProcessBrowserTest:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
-    command_line->AppendSwitch(
-        switches::kEnablePushMessagePayload);
-
+    command_line->AppendSwitch(switches::kEnablePushMessagePayload);
     InProcessBrowserTest::SetUpCommandLine(command_line);
   }
 
   // InProcessBrowserTest:
   void SetUp() override {
     https_server_.reset(new net::SpawnedTestServer(
         net::SpawnedTestServer::TYPE_HTTPS,
         net::BaseTestServer::SSLOptions(
             net::BaseTestServer::SSLOptions::CERT_OK),
         base::FilePath(FILE_PATH_LITERAL("chrome/test/data/"))));
@@ skipping 89 matching lines @@
 };
 
 class PushMessagingBadManifestBrowserTest : public PushMessagingBrowserTest {
   std::string GetTestURL() override {
     return "files/push_messaging/test_bad_manifest.html";
   }
 };
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBadManifestBrowserTest,
                        RegisterFailsNotVisibleMessages) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
   ASSERT_TRUE(RunScript("registerPush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - permission denied",
             script_result);
 }
 
 void PushMessagingBrowserTest::TryToRegisterSuccessfully(
@@ skipping 16 matching lines @@
     int64 service_worker_registration_id) {
   GURL origin = https_server()->GetURL("").GetOrigin();
   PushMessagingApplicationId application_id = PushMessagingApplicationId::Get(
       browser()->profile(), origin, service_worker_registration_id);
   EXPECT_TRUE(application_id.IsValid());
   return application_id;
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        RegisterSuccessNotificationsGranted) {
+  if (!IsPushSupported())
+    return;
+
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id = GetServiceWorkerAppId(0LL);
   EXPECT_EQ(app_id.app_id_guid, gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        RegisterSuccessNotificationsPrompt) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   InfoBarResponder accepting_responder(browser(), true);
   ASSERT_TRUE(RunScript("registerPush()", &script_result));
   EXPECT_EQ(std::string(kPushMessagingEndpoint) + " - 1-0", script_result);
 
   PushMessagingApplicationId app_id = GetServiceWorkerAppId(0LL);
   EXPECT_EQ(app_id.app_id_guid, gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        RegisterFailureNotificationsBlocked) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   InfoBarResponder cancelling_responder(browser(), false);
   ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
   ASSERT_EQ("permission status - denied", script_result);
 
   ASSERT_TRUE(RunScript("registerPush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - permission denied",
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, RegisterFailureNoManifest) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   InfoBarResponder accepting_responder(browser(), true);
   ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
   ASSERT_EQ("permission status - granted", script_result);
 
   ASSERT_TRUE(RunScript("removeManifest()", &script_result));
   ASSERT_EQ("manifest removed", script_result);
 
   ASSERT_TRUE(RunScript("registerPush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - no sender id provided",
             script_result);
 }
 
 // TODO(johnme): Test registering from a worker - see https://crbug.com/437298.
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, RegisterPersisted) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   // First, test that Service Worker registration IDs are assigned in order of
   // registering the Service Workers, and the (fake) push registration ids are
   // assigned in order of push registration (even when these orders are
   // different).
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
   PushMessagingApplicationId app_id_sw0 = GetServiceWorkerAppId(0LL);
   EXPECT_EQ(app_id_sw0.app_id_guid, gcm_service()->last_registered_app_id());
@@ skipping 34 matching lines @@
   LoadTestPage("files/push_messaging/subscope2/test.html");
   TryToRegisterSuccessfully("1-1" /* expected_push_registration_id */);
   EXPECT_EQ(app_id_sw1.app_id_guid, gcm_service()->last_registered_app_id());
 
   LoadTestPage();
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
   EXPECT_EQ(app_id_sw1.app_id_guid, gcm_service()->last_registered_app_id());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventSuccess) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id = GetServiceWorkerAppId(0LL);
   EXPECT_EQ(app_id.app_id_guid, gcm_service()->last_registered_app_id());
   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;
   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;
+
   std::string script_result;
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id = GetServiceWorkerAppId(0LL);
   EXPECT_EQ(app_id.app_id_guid, gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
@@ skipping 19 matching lines @@
 
   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);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PushEventNoPermission) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id = GetServiceWorkerAppId(0LL);
   EXPECT_EQ(app_id.app_id_guid, gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
@@ skipping 21 matching lines @@
   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);
 }
 
 #if defined(ENABLE_NOTIFICATIONS)
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        PushEventEnforcesUserVisibleNotification) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id = GetServiceWorkerAppId(0LL);
   EXPECT_EQ(app_id.app_id_guid, gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 
   ASSERT_TRUE(RunScript("isControlled()", &script_result));
   ASSERT_EQ("false - is not controlled", script_result);
@@ skipping 71 matching lines @@
   // allow the next one to mistakenly not show a notification.
   message.data["data"] = "testdata";
   push_service()->OnMessage(app_id.app_id_guid, message);
   ASSERT_TRUE(RunScript("resultQueue.pop()", &script_result, web_contents));
   EXPECT_EQ("testdata", script_result);
   EXPECT_EQ(0u, notification_manager()->GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        PushEventNotificationWithoutEventWaitUntil) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   PushMessagingApplicationId app_id = GetServiceWorkerAppId(0LL);
   EXPECT_EQ(app_id.app_id_guid, gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 
@@ skipping 21 matching lines @@
   EXPECT_EQ(base::ASCIIToUTF16("push_test_tag"),
             notification_manager()->GetNotificationAt(0).replace_id());
 
   // Verify that the renderer process hasn't crashed.
   ASSERT_TRUE(RunScript("hasPermission()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, HasPermissionSaysDefault) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   ASSERT_TRUE(RunScript("hasPermission()", &script_result));
   ASSERT_EQ("permission status - default", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, HasPermissionSaysGranted) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   InfoBarResponder accepting_responder(browser(), true);
   ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 
   ASSERT_TRUE(RunScript("registerPush()", &script_result));
   EXPECT_EQ(std::string(kPushMessagingEndpoint) + " - 1-0", script_result);
 
   ASSERT_TRUE(RunScript("hasPermission()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, HasPermissionSaysDenied) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   InfoBarResponder cancelling_responder(browser(), false);
   ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
   EXPECT_EQ("permission status - denied", script_result);
 
   ASSERT_TRUE(RunScript("registerPush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - permission denied",
             script_result);
 
   ASSERT_TRUE(RunScript("hasPermission()", &script_result));
   EXPECT_EQ("permission status - denied", script_result);
 }
 
 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);
 
   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);
 
   ASSERT_TRUE(RunScript("unregister()", &script_result));
   EXPECT_EQ("unregister error: "
             "NetworkError: Failed to connect to the push server.",
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, UnregisterUnknownError) {
+  if (!IsPushSupported())
+    return;
+
   std::string script_result;
 
   TryToRegisterSuccessfully("1-0" /* expected_push_registration_id */);
 
   gcm_service()->AddExpectedUnregisterResponse(GCMClient::UNKNOWN_ERROR);
 
   ASSERT_TRUE(RunScript("unregister()", &script_result));
   EXPECT_EQ("unregister error: "
             "UnknownError: Unexpected error while trying to unregister from the"
             " push server.", 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
+  // is not available on that version of Android.
+  if (IsPushSupported())
+    return;
+
+  std::string script_result;
+  ASSERT_TRUE(RunScript("window.PushManager", &script_result));
+  EXPECT_EQ("undefined", script_result);
+}
+#endif
+
 }  // namespace gcm