Reject connection attempts without prompt if target app doesn't handle the event anyway.

chrome/browser/extensions/extension_messages_apitest.cc

 // Copyright (c) 2012 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 "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 288 matching lines @@
                                  "  %s,"
                                  "  \"externally_connectable\": {"
                                  "    \"matches\": [\"*://*.chromium.org:*/*\"]"
                                  "  }"
                                  "}",
                                  common_manifest()));
     CHECK(extension.get());
     return extension;
   }
 
-  scoped_refptr<const Extension> LoadChromiumConnectableApp() {
+  scoped_refptr<const Extension> LoadChromiumConnectableApp(
+      bool with_event_handlers = true) {
     scoped_refptr<const Extension> extension =
         LoadExtensionIntoDir(&web_connectable_dir_,
                              "{"
                              "  \"app\": {"
                              "    \"background\": {"
                              "      \"scripts\": [\"background.js\"]"
                              "    }"
                              "  },"
                              "  \"externally_connectable\": {"
                              "    \"matches\": [\"*://*.chromium.org:*/*\"]"
                              "  },"
                              "  \"manifest_version\": 2,"
                              "  \"name\": \"app_connectable\","
                              "  \"version\": \"1.0\""
-                             "}");
+                             "}",
+                             with_event_handlers);
     CHECK(extension.get());
     return extension;
   }
 
   scoped_refptr<const Extension> LoadNotConnectableExtension() {
     scoped_refptr<const Extension> extension =
         LoadExtensionIntoDir(&not_connectable_dir_,
                              base::StringPrintf(
                                  "{"
                                  "  \"name\": \"not_connectable\","
@@ skipping 40 matching lines @@
     host_resolver()->AddRule("*", embedded_test_server()->base_url().host());
   }
 
   const char* close_background_message() {
     return "closeBackgroundPage";
   }
 
  private:
   scoped_refptr<const Extension> LoadExtensionIntoDir(
       TestExtensionDir* dir,
-      const std::string& manifest) {
+      const std::string& manifest,
+      bool with_event_handlers = true) {
     dir->WriteManifest(manifest);
-    dir->WriteFile(FILE_PATH_LITERAL("background.js"),
-                   base::StringPrintf(
-        "function maybeClose(message) {\n"
-        "  if (message.indexOf('%s') >= 0)\n"
-        "    window.setTimeout(function() { window.close() }, 0);\n"
-        "}\n"
-        "chrome.runtime.onMessageExternal.addListener(\n"
-        "    function(message, sender, reply) {\n"
-        "  reply({ message: message, sender: sender });\n"
-        "  maybeClose(message);\n"
-        "});\n"
-        "chrome.runtime.onConnectExternal.addListener(function(port) {\n"
-        "  port.onMessage.addListener(function(message) {\n"
-        "    port.postMessage({ message: message, sender: port.sender });\n"
-        "    maybeClose(message);\n"
-        "  });\n"
-        "});\n",
-                   close_background_message()));
+    if (with_event_handlers) {
+      dir->WriteFile(
+          FILE_PATH_LITERAL("background.js"),
+          base::StringPrintf(
+              "function maybeClose(message) {\n"
+              "  if (message.indexOf('%s') >= 0)\n"
+              "    window.setTimeout(function() { window.close() }, 0);\n"
+              "}\n"
+              "chrome.runtime.onMessageExternal.addListener(\n"
+              "    function(message, sender, reply) {\n"
+              "  reply({ message: message, sender: sender });\n"
+              "  maybeClose(message);\n"
+              "});\n"
+              "chrome.runtime.onConnectExternal.addListener(function(port) {\n"
+              "  port.onMessage.addListener(function(message) {\n"
+              "    port.postMessage({ message: message, sender: port.sender "
+              "});\n"
+              "    maybeClose(message);\n"
+              "  });\n"
+              "});\n",
+              close_background_message()));
+    } else {
+      dir->WriteFile(FILE_PATH_LITERAL("background.js"), "");
+    }
     return LoadExtension(dir->unpacked_path());
   }
 
   const char* common_manifest() {
     return "\"version\": \"1.0\","
            "\"background\": {"
            "    \"scripts\": [\"background.js\"],"
            "    \"persistent\": false"
            "},"
            "\"manifest_version\": 2";
@@ skipping 313 matching lines @@
     EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
   }
 
   // Allowing the extension in incognito mode will bypass the deny.
   ExtensionPrefs::Get(profile())->SetIsIncognitoEnabled(extension->id(), true);
   EXPECT_EQ(
       OK,
       CanConnectAndSendMessagesToFrame(incognito_frame, extension.get(), NULL));
 }
 
+// Tests connection from incognito tabs when the extension doesn't have an event
+// handler for the connection event.
+IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
+                       FromIncognitoNoEventHandlerInApp) {
+  InitializeTestServer();
+
+  scoped_refptr<const Extension> app = LoadChromiumConnectableApp(false);
+  ASSERT_TRUE(app->is_platform_app());
+
+  Browser* incognito_browser = ui_test_utils::OpenURLOffTheRecord(
+      profile()->GetOffTheRecordProfile(), chromium_org_url());
+  content::RenderFrameHost* incognito_frame =
+      incognito_browser->tab_strip_model()
+          ->GetActiveWebContents()
+          ->GetMainFrame();
+
+  {
+    IncognitoConnectability::ScopedAlertTracker alert_tracker(
+        IncognitoConnectability::ScopedAlertTracker::ALWAYS_ALLOW);
+
+    // No connection because incognito-enabled hasn't been set for the app, and
+    // the app hasn't installed event handlers.
+    EXPECT_EQ(
+        COULD_NOT_ESTABLISH_CONNECTION_ERROR,
+        CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
+    // No dialog should have been shown.
+    EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
+  }
+}
+
 // Tests connection from incognito tabs when the user accepts the connection
 // request. Spanning mode only. Separate tests for apps and extensions.
 //
 // TODO(kalman): see comment above about split mode.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoAllowApp) {
   InitializeTestServer();
 
   scoped_refptr<const Extension> app = LoadChromiumConnectableApp();
   ASSERT_TRUE(app->is_platform_app());
@@ skipping 398 matching lines @@
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
             CanConnectAndSendMessagesToMainFrame(invalid.get()));
 }
 
 #endif  // !defined(OS_WIN) - http://crbug.com/350517.
 
 }  // namespace
 
 };  // namespace extensions