Pass handle of the native view window to the native messaging host.

chrome/browser/extensions/api/messaging/native_process_launcher.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_process_launcher.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/extensions/api/messaging/native_messaging_host_manifest.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
-const char kNativeHostsDirectoryName[] = "native_hosts";
+// Name of the command line switch used to pass handle of the native view to
+// the native messaging host.
+const char kParentWindowSwitchName[] = "parent-window";
 
 base::FilePath GetHostManifestPathFromCommandLine(
     const std::string& native_host_name) {
   const std::string& value =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kNativeMessagingHosts);
   if (value.empty())
     return base::FilePath();
 
   std::vector<std::string> hosts;
   base::SplitString(value, ',', &hosts);
   for (size_t i = 0; i < hosts.size(); ++i) {
     std::vector<std::string> key_and_value;
     base::SplitString(hosts[i], '=', &key_and_value);
     if (key_and_value.size() != 2)
       continue;
     if (key_and_value[0] == native_host_name)
       return base::FilePath::FromUTF8Unsafe(key_and_value[1]);
   }
 
   return base::FilePath();
 }
 
 
 // Default implementation on NativeProcessLauncher interface.
 class NativeProcessLauncherImpl : public NativeProcessLauncher {
  public:
-  NativeProcessLauncherImpl();
+  explicit NativeProcessLauncherImpl(gfx::NativeView native_view);
   virtual ~NativeProcessLauncherImpl();
 
   virtual void Launch(const GURL& origin,
                       const std::string& native_host_name,
                       LaunchedCallback callback) const OVERRIDE;
 
  private:
   class Core : public base::RefCountedThreadSafe<Core> {
    public:
-    Core();
+    explicit Core(gfx::NativeView native_view);
     void Launch(const GURL& origin,
                 const std::string& native_host_name,
                 LaunchedCallback callback);
     void Detach();
 
    private:
     friend class base::RefCountedThreadSafe<Core>;
     virtual ~Core();
 
     void DoLaunchOnThreadPool(const GURL& origin,
                               const std::string& native_host_name,
                               LaunchedCallback callback);
     void PostErrorResult(const LaunchedCallback& callback, LaunchResult error);
     void PostResult(const LaunchedCallback& callback,
                     base::PlatformFile read_file,
                     base::PlatformFile write_file);
     void CallCallbackOnIOThread(LaunchedCallback callback,
                                 LaunchResult result,
                                 base::PlatformFile read_file,
                                 base::PlatformFile write_file);
 
     bool detached_;
 
+    // Handle of the native view corrsponding to the extension.
+    gfx::NativeView native_view_;
+
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeProcessLauncherImpl);
 };
 
-NativeProcessLauncherImpl::Core::Core()
-    : detached_(false) {
+NativeProcessLauncherImpl::Core::Core(gfx::NativeView native_view)
+    : detached_(false),
+      native_view_(native_view) {
 }
 
 NativeProcessLauncherImpl::Core::~Core() {
   DCHECK(detached_);
 }
 
 void NativeProcessLauncherImpl::Core::Detach() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   detached_ = true;
 }
@@ skipping 67 matching lines @@
     LOG(ERROR) << "Native messaging host path must be absolute for "
                << native_host_name;
     PostErrorResult(callback, RESULT_NOT_FOUND);
     return;
 #endif  // !defined(OS_WIN)
   }
 
   CommandLine command_line(host_path);
   command_line.AppendArg(origin.spec());
 
+  // Pass handle of the native view window to the native messaging host. This
+  // way the host will be able to create properly focused UI windows.
+#if defined(OS_WIN)
+  int64 window_handle = reinterpret_cast<intptr_t>(native_view_);
+  command_line.AppendSwitchASCII(kParentWindowSwitchName,
+                                 base::Int64ToString(window_handle));
+#endif  // !defined(OS_WIN)
+
   base::PlatformFile read_file;
   base::PlatformFile write_file;
   if (NativeProcessLauncher::LaunchNativeProcess(
           command_line, &read_file, &write_file)) {
     PostResult(callback, read_file, write_file);
   } else {
     PostErrorResult(callback, RESULT_FAILED_TO_START);
   }
 }
 
@@ skipping 28 matching lines @@
 void NativeProcessLauncherImpl::Core::PostResult(
     const LaunchedCallback& callback,
     base::PlatformFile read_file,
     base::PlatformFile write_file) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&NativeProcessLauncherImpl::Core::CallCallbackOnIOThread,
                  this, callback, RESULT_SUCCESS, read_file, write_file));
 }
 
-NativeProcessLauncherImpl::NativeProcessLauncherImpl()
-  : core_(new Core()) {
+NativeProcessLauncherImpl::NativeProcessLauncherImpl(
+    gfx::NativeView native_view)
+  : core_(new Core(native_view)) {
 }
 
 NativeProcessLauncherImpl::~NativeProcessLauncherImpl() {
   core_->Detach();
 }
 
 void NativeProcessLauncherImpl::Launch(const GURL& origin,
                                        const std::string& native_host_name,
                                        LaunchedCallback callback) const {
   core_->Launch(origin, native_host_name, callback);
 }
 
 }  // namespace
 
 // static
-scoped_ptr<NativeProcessLauncher> NativeProcessLauncher::CreateDefault() {
-  return scoped_ptr<NativeProcessLauncher>(new NativeProcessLauncherImpl());
+scoped_ptr<NativeProcessLauncher> NativeProcessLauncher::CreateDefault(
+    gfx::NativeView native_view) {
+  return scoped_ptr<NativeProcessLauncher>(
+      new NativeProcessLauncherImpl(native_view));
 }
 
 }  // namespace extensions