Require manifests for native messaging hosts.

chrome/browser/extensions/api/messaging/native_message_process_host.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/native_message_process_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/process_util.h"
 #include "base/values.h"
+#include "chrome/browser/extensions/api/messaging/native_messaging_host_manifest.h"
 #include "chrome/browser/extensions/api/messaging/native_process_launcher.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/features/feature.h"
+#include "extensions/common/constants.h"
+#include "googleurl/src/gurl.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 
 namespace {
 
 const int kExitTimeoutMS = 5000;
 const uint32 kMaxMessageDataLength = 10 * 1024 * 1024;
 
 // Message header contains 4-byte integer size of the message.
 const size_t kMessageHeaderSize = 4;
 
 // Size of the buffer to be allocated for each read.
 const size_t kReadBufferSize = 4096;
 
 }  // namespace
 
 namespace extensions {
 
 NativeMessageProcessHost::NativeMessageProcessHost(
     base::WeakPtr<Client> weak_client_ui,
+    const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
     scoped_ptr<NativeProcessLauncher> launcher)
     : weak_client_ui_(weak_client_ui),
+      source_extension_id_(source_extension_id),
       native_host_name_(native_host_name),
       destination_port_(destination_port),
       launcher_(launcher.Pass()),
       closed_(false),
       native_process_handle_(base::kNullProcessHandle),
       read_pending_(false),
       read_eof_(false),
       write_pending_(false) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // It's safe to use base::Unretained() here because NativeMessagePort always
   // deletes us on the IO thread.
   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
       base::Bind(&NativeMessageProcessHost::LaunchHostProcess,
                  base::Unretained(this)));
 }
 
 NativeMessageProcessHost::~NativeMessageProcessHost() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   Close();
 }
 
 // static
 scoped_ptr<NativeMessageProcessHost> NativeMessageProcessHost::Create(
     base::WeakPtr<Client> weak_client_ui,
+    const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port) {
-  return CreateWithLauncher(weak_client_ui, native_host_name, destination_port,
+  return CreateWithLauncher(weak_client_ui, source_extension_id,
+                            native_host_name, destination_port,
                             NativeProcessLauncher::CreateDefault());
 }
 
 // static
 scoped_ptr<NativeMessageProcessHost>
 NativeMessageProcessHost::CreateWithLauncher(
     base::WeakPtr<Client> weak_client_ui,
+    const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
     scoped_ptr<NativeProcessLauncher> launcher) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<NativeMessageProcessHost> process;
   if (Feature::GetCurrentChannel() > chrome::VersionInfo::CHANNEL_DEV ||
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableNativeMessaging)) {
     return process.Pass();
   }
 
   process.reset(new NativeMessageProcessHost(
-      weak_client_ui, native_host_name, destination_port, launcher.Pass()));
+      weak_client_ui, source_extension_id, native_host_name,
+      destination_port, launcher.Pass()));
 
   return process.Pass();
 }
 
 void NativeMessageProcessHost::LaunchHostProcess() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
-  launcher_->Launch(
-      native_host_name_, base::Bind(
-          &NativeMessageProcessHost::OnHostProcessLaunched,
-          base::Unretained(this)));
+  GURL origin(std::string(kExtensionScheme) + "://" + source_extension_id_);
+  launcher_->Launch(origin, native_host_name_,
+                    base::Bind(&NativeMessageProcessHost::OnHostProcessLaunched,
+                               base::Unretained(this)));
 }
 
 void NativeMessageProcessHost::OnHostProcessLaunched(
     base::ProcessHandle native_process_handle,
     base::PlatformFile read_file,
     base::PlatformFile write_file) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   if (native_process_handle == base::kNullProcessHandle) {
     OnError();
@@ skipping 204 matching lines @@
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(base::IgnoreResult(&base::KillProcess),
                  native_process_handle_, 0,
                  false /* don't wait for exit */),
       base::TimeDelta::FromMilliseconds(kExitTimeoutMS));
     native_process_handle_ = base::kNullProcessHandle;
   }
 }
 
 }  // namespace extensions