[Extensions] Determine NativeMessaging ID solely on the browser process

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 <stdint.h>
 #include <limits>
 #include <utility>
 
@@ skipping 25 matching lines @@
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_api_frame_id_map.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
+#include "extensions/browser/extension_web_contents_observer.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/guest_view/web_view/web_view_guest.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/externally_connectable.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
@@ skipping 343 matching lines @@
     return;
   }
 
   OnOpenChannelAllowed(std::move(params), true);
 }
 
 void MessageService::OpenChannelToNativeApp(
     int source_process_id,
     int source_routing_id,
     int receiver_port_id,
-    const std::string& source_extension_id,
     const std::string& native_app_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   content::RenderFrameHost* source =
       content::RenderFrameHost::FromID(source_process_id, source_routing_id);
   if (!source)
     return;
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
-  Profile* profile =
-      Profile::FromBrowserContext(source->GetProcess()->GetBrowserContext());
-  ExtensionService* extension_service =
-      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->permissions_data()->HasAPIPermission(
-                         APIPermission::kNativeMessaging);
-  }
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderFrameHost(source);;

[dcheng, 2016/05/24 04:41:46]

Nit: double semicolon here.

[Devlin, 2016/05/24 21:59:08]

Done.

+  ExtensionWebContentsObserver* extension_web_contents_observer =
+      web_contents ?
+          ExtensionWebContentsObserver::GetForWebContents(web_contents) :
+          nullptr;
+  const Extension* extension =
+      extension_web_contents_observer ?
+          extension_web_contents_observer->GetExtensionFromFrame(source, true) :
+          nullptr;
+
+  bool has_permission = extension &&
+                        extension->permissions_data()->HasAPIPermission(
+                            APIPermission::kNativeMessaging);
 
   if (!has_permission) {
     DispatchOnDisconnect(source, receiver_port_id, kMissingPermissionError);
     return;
   }
 
-  PrefService* pref_service = profile->GetPrefs();
+  PrefService* pref_service =
+      Profile::FromBrowserContext(source->GetProcess()->GetBrowserContext())->
+          GetPrefs();
 
   // Verify that the host is not blocked by policies.
   PolicyPermission policy_permission =
       IsNativeMessagingHostAllowed(pref_service, native_app_name);
   if (policy_permission == DISALLOW) {
     DispatchOnDisconnect(source, receiver_port_id, kProhibitedByPoliciesError);
     return;
   }
 
   std::unique_ptr<MessageChannel> channel(new MessageChannel());
   channel->opener.reset(
       new ExtensionMessagePort(weak_factory_.GetWeakPtr(),
                                GET_OPPOSITE_PORT_ID(receiver_port_id),
-                               source_extension_id, source, false));
+                               extension->id(), source, false));
   if (!channel->opener->IsValidPort())
     return;
   channel->opener->OpenPort(source_process_id, source_routing_id);
 
   // Get handle of the native view and pass it to the native messaging host.
   gfx::NativeView native_view = source ? source->GetNativeView() : nullptr;
 
   std::string error = kReceivingEndDoesntExistError;
   std::unique_ptr<NativeMessageHost> native_host = NativeMessageHost::Create(
-      native_view, source_extension_id, native_app_name,
+      native_view, extension->id(), native_app_name,
       policy_permission == ALLOW_ALL, &error);
 
   // Abandon the channel.
   if (!native_host.get()) {
     LOG(ERROR) << "Failed to create native process.";
     DispatchOnDisconnect(source, receiver_port_id, error);
     return;
   }
   channel->receiver.reset(new NativeMessagePort(
       weak_factory_.GetWeakPtr(), receiver_port_id, std::move(native_host)));
@@ skipping 538 matching lines @@
 
   MessageChannelMap::iterator channel_iter = channels_.find(channel_id);
   if (channel_iter != channels_.end()) {
     for (const PendingMessage& message : queue) {
       DispatchMessage(message.first, channel_iter->second, message.second);
     }
   }
 }
 
 }  // namespace extensions