Pass correct --parent-window value to native messaging hosts

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"
 
+#if defined(OS_WIN)
+#include "ui/aura/root_window.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
+#endif
+
 namespace extensions {
 
 namespace {
 
 #if defined(OS_WIN)
 // Name of the command line switch used to pass handle of the native view to
 // the native messaging host.
 const char kParentWindowSwitchName[] = "parent-window";
 #endif  // defined(OS_WIN)
 
@@ skipping 16 matching lines @@
       return base::FilePath::FromUTF8Unsafe(key_and_value[1]);
   }
 
   return base::FilePath();
 }
 
 
 // Default implementation on NativeProcessLauncher interface.
 class NativeProcessLauncherImpl : public NativeProcessLauncher {
  public:
-  explicit NativeProcessLauncherImpl(gfx::NativeView native_view);
+  explicit NativeProcessLauncherImpl(intptr_t native_window);
   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:
-    explicit Core(gfx::NativeView native_view);
+    explicit Core(intptr_t native_window);
     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::ProcessHandle process_handle,
                     base::PlatformFile read_file,
                     base::PlatformFile write_file);
     void CallCallbackOnIOThread(LaunchedCallback callback,
                                 LaunchResult result,
                                 base::ProcessHandle process_handle,
                                 base::PlatformFile read_file,
                                 base::PlatformFile write_file);
 
     bool detached_;
 
-    // Handle of the native view corrsponding to the extension.
-    gfx::NativeView native_view_;
+    // Handle of the native window corresponding to the extension.
+    intptr_t window_handle_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeProcessLauncherImpl);
 };
 
-NativeProcessLauncherImpl::Core::Core(gfx::NativeView native_view)
+NativeProcessLauncherImpl::Core::Core(intptr_t window_handle)
     : detached_(false),
-      native_view_(native_view) {
+      window_handle_(window_handle) {
 }
 
 NativeProcessLauncherImpl::Core::~Core() {
   DCHECK(detached_);
 }
 
 void NativeProcessLauncherImpl::Core::Detach() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   detached_ = true;
 }
@@ skipping 70 matching lines @@
     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));
+                                 base::Int64ToString(window_handle_));
 #endif  // !defined(OS_WIN)
 
   base::ProcessHandle process_handle;
   base::PlatformFile read_file;
   base::PlatformFile write_file;
   if (NativeProcessLauncher::LaunchNativeProcess(
           command_line, &process_handle, &read_file, &write_file)) {
     PostResult(callback, process_handle, read_file, write_file);
   } else {
     PostErrorResult(callback, RESULT_FAILED_TO_START);
@@ skipping 34 matching lines @@
     base::ProcessHandle process_handle,
     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, process_handle, read_file,
                  write_file));
 }
 
-NativeProcessLauncherImpl::NativeProcessLauncherImpl(
-    gfx::NativeView native_view)
-  : core_(new Core(native_view)) {
+NativeProcessLauncherImpl::NativeProcessLauncherImpl(intptr_t window_handle)
+  : core_(new Core(window_handle)) {
 }
 
 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(
     gfx::NativeView native_view) {
+  intptr_t window_handle = 0;
+#if defined(OS_WIN)
+  window_handle = reinterpret_cast<intptr_t>(
+      native_view->GetDispatcher()->host()->GetAcceleratedWidget());
+#endif
   return scoped_ptr<NativeProcessLauncher>(
-      new NativeProcessLauncherImpl(native_view));
+      new NativeProcessLauncherImpl(window_handle));
 }
 
 }  // namespace extensions