Implement externally_connectable! Web pages can now communicate directly with

chrome/browser/extensions/api/messaging/message_service.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 "chrome/browser/extensions/api/messaging/message_service.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/messaging/extension_message_port.h"
 #include "chrome/browser/extensions/api/messaging/native_message_port.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/incognito_handler.h"
+#include "chrome/common/extensions/manifest_handlers/externally_connectable.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
 
 using content::SiteInstance;
 using content::WebContents;
@@ skipping 139 matching lines @@
     const std::string& channel_name) {
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
   Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
 
   const Extension* target_extension = ExtensionSystem::Get(profile)->
       extension_service()->extensions()->GetByID(target_extension_id);
   if (!target_extension) {
-    // Treat it as a disconnect.
-    ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, std::string());
-    port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(receiver_port_id),
-                              kReceivingEndDoesntExistError);
+    DispatchOnDisconnect(
+        source, receiver_port_id, kReceivingEndDoesntExistError);
     return;
   }
 
+  if (source_extension_id != target_extension_id) {
+    // It's an external connection. Check the externally_connectable manifest
+    // key if it's present. If it's not, we allow connection from any extension
+    // but not webpages.
+    ExternallyConnectableInfo* externally_connectable =
+        static_cast<ExternallyConnectableInfo*>(
+            target_extension->GetManifestData(
+                extension_manifest_keys::kExternallyConnectable));
+    bool is_externally_connectable = true;

[Jeffrey Yasskin, 2013/06/08 00:28:09]

Default this to false in order to fail safe. (i.e. if your if's aren't
exhaustive, you want this to block connecting.)

Or extract the decision logic into a (static?) function that can return its
decision.

[not at google - send to devlin, 2013/06/08 02:02:33]

Default to false, static function looks a bit contrived.

+
+    if (externally_connectable) {
+      if (source_extension_id.empty()) {
+        // No source extension ID so the source was a web page. Check that the
+        // URL matches.
+        is_externally_connectable =
+            externally_connectable->matches.MatchesURL(source_url);
+      } else {
+        // Source extension ID so the source was an extension. Check that the
+        // extension matches.
+        is_externally_connectable =
+            externally_connectable->MatchesIdOrAllIds(source_extension_id);
+      }
+    } else {
+      // Legacy behaviour. Any extension, no webpages.

[Jeffrey Yasskin, 2013/06/08 00:28:09]

What makes this legacy? Is there a plan to require the externally_connectable
key, say in manifest v3? If users want to opt out of the legacy behavior, how do
they do it? (This needs to make its way to the documentation (i.e. add a TODO),
but you can just comment it for now.)

[not at google - send to devlin, 2013/06/08 02:02:33]

Fair enough, legacy is the wrong word. I don't see any reason to deprecate the
default behaviour.

+      is_externally_connectable = !source_extension_id.empty();
+    }
+
+    if (!is_externally_connectable) {
+      DispatchOnDisconnect(
+          source, receiver_port_id, kReceivingEndDoesntExistError);

[Jeffrey Yasskin, 2013/06/08 00:28:09]

This message is, of course, a lie. Please comment why we need to lie so someone
doesn't "correct" it.

[not at google - send to devlin, 2013/06/08 02:02:33]

Done.

+      return;
+    }
+  }
+
   // Note: we use the source's profile here. If the source is an incognito
   // process, we will use the incognito EPM to find the right extension process,
   // which depends on whether the extension uses spanning or split mode.
   MessagePort* receiver = new ExtensionMessagePort(
       GetExtensionProcess(profile, target_extension_id), MSG_ROUTING_CONTROL,
       target_extension_id);
   WebContents* source_contents = tab_util::GetWebContentsByID(
       source_process_id, source_routing_id);
 
   // Include info about the opener's tab (if it was a tab).
@@ skipping 43 matching lines @@
       extensions::ExtensionSystem::Get(profile)->extension_service();
   bool has_permission = false;
   if (extension_service) {
     const Extension* extension =
         extension_service->GetExtensionById(source_extension_id, false);
     has_permission = extension && extension->HasAPIPermission(
         APIPermission::kNativeMessaging);
   }
 
   if (!has_permission) {
-    ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, std::string());
-    port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(receiver_port_id),
-                              kMissingPermissionError);
+    DispatchOnDisconnect(source, receiver_port_id, kMissingPermissionError);
     return;
   }
 
   scoped_ptr<MessageChannel> channel(new MessageChannel());
   channel->opener.reset(new ExtensionMessagePort(source, MSG_ROUTING_CONTROL,
                                                  source_extension_id));
 
   scoped_ptr<NativeMessageProcessHost> native_process =
       NativeMessageProcessHost::Create(
           base::WeakPtr<NativeMessageProcessHost::Client>(
               weak_factory_.GetWeakPtr()),
           source_extension_id, native_app_name, receiver_port_id);
 
   // Abandon the channel.
   if (!native_process.get()) {
     LOG(ERROR) << "Failed to create native process.";
-    // Treat it as a disconnect.
-    ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, std::string());
-    port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(receiver_port_id),
-                              kReceivingEndDoesntExistError);
+    DispatchOnDisconnect(
+        source, receiver_port_id, kReceivingEndDoesntExistError);
     return;
   }
   channel->receiver.reset(new NativeMessagePort(native_process.release()));
 
   // Keep the opener alive until the channel is closed.
   channel->opener->IncrementLazyKeepaliveCount();
 
   AddChannel(channel.release(), receiver_port_id);
 #else  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
-  ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, "");
-  port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(receiver_port_id),
-                            kNativeMessagingNotSupportedError);
+  DispatchOnDisconnect(
+      source, receiver_port_id, kNativeMessagingNotSupportedError);
 #endif  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
 }
 
 void MessageService::OpenChannelToTab(
     int source_process_id, int source_routing_id, int receiver_port_id,
     int tab_id, const std::string& extension_id,
     const std::string& channel_name) {
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
   Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
 
   WebContents* contents = NULL;
   scoped_ptr<MessagePort> receiver;
   if (ExtensionTabUtil::GetTabById(tab_id, profile, true,
                                    NULL, NULL, &contents, NULL)) {
     receiver.reset(new ExtensionMessagePort(
         contents->GetRenderProcessHost(),
         contents->GetRenderViewHost()->GetRoutingID(),
         extension_id));
   }
 
   if (contents && contents->GetController().NeedsReload()) {
-    // The tab isn't loaded yet. Don't attempt to connect. Treat this as a
-    // disconnect.
-    ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, extension_id);
-    port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(receiver_port_id),
-                              kReceivingEndDoesntExistError);
+    // The tab isn't loaded yet. Don't attempt to connect.
+    DispatchOnDisconnect(source,
+                         receiver_port_id,
+                         extension_id,
+                         kReceivingEndDoesntExistError);
     return;
   }
 
   scoped_ptr<OpenChannelParams> params(new OpenChannelParams(
         source,
         scoped_ptr<DictionaryValue>(),  // Source tab doesn't make sense for
                                         // opening to tabs.
         receiver.release(),
         receiver_port_id,
         extension_id,
         extension_id,
         GURL(),  // Source URL doesn't make sense for opening to tabs.
         channel_name));
   OpenChannelImpl(params.Pass());
 }
 
 bool MessageService::OpenChannelImpl(scoped_ptr<OpenChannelParams> params) {
   if (!params->source)
     return false;  // Closed while in flight.
 
   if (!params->receiver || !params->receiver->GetRenderProcessHost()) {
-    // Treat it as a disconnect.
-    ExtensionMessagePort port(
-        params->source, MSG_ROUTING_CONTROL, std::string());
-    port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(params->receiver_port_id),
-                              kReceivingEndDoesntExistError);
+    DispatchOnDisconnect(params->source,
+                         params->receiver_port_id,
+                         kReceivingEndDoesntExistError);
     return false;
   }
 
   // Add extra paranoid CHECKs, since we have crash reports of this being NULL.
   // http://code.google.com/p/chromium/issues/detail?id=19067
   CHECK(params->receiver->GetRenderProcessHost());
 
   MessageChannel* channel(new MessageChannel);
   channel->opener.reset(new ExtensionMessagePort(params->source,
                                                  MSG_ROUTING_CONTROL,
@@ skipping 183 matching lines @@
   if (!source)
     return;
 
   params->source = source;
   params->receiver.reset(new ExtensionMessagePort(host->render_process_host(),
                                                   MSG_ROUTING_CONTROL,
                                                   params->target_extension_id));
   OpenChannelImpl(params.Pass());
 }
 
+void MessageService::DispatchOnDisconnect(content::RenderProcessHost* source,
+                                          int port_id,
+                                          const std::string& extension_id,
+                                          const std::string& reason) {
+  ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, extension_id);
+  port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(port_id), reason);
+}
+
 }  // namespace extensions