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";
+const char kNativeViewSwitchName[] = "native_view";
 
 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::NativeWindow 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::NativeWindow 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::NativeWindow 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::NativeWindow 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.

[Sergey Ulanov, 2013/08/07 22:51:20]

explain why it can be useful please.

[alexeypa (please no reviews), 2013/08/08 16:57:32]

Done.

+#if defined(OS_WIN)
+  int64 window_handle = reinterpret_cast<intptr_t>(native_view_);
+  command_line.AppendSwitchASCII(kNativeViewSwitchName,
+                                 base::Int64ToString(window_handle));

[Sergey Ulanov, 2013/08/07 22:51:20]

Maybe use hexadecimal form instead of decimal number? Also, I suggest using
uintptr_t and uint64 - that will allow to avoid minus sign when formatting it to
string.

[alexeypa (please no reviews), 2013/08/08 16:57:32]

Parsing a decimal value is typically more common (and therefore more tested)
operation than parsing a hex value. For instance, many routines do not expect
"0x" prefix. Not adding the prefix is an option but than it will not be apparent
that it is a hexadecimal number. 
The minus sign is understood by conversion routines. Given that the handles are
signed I'd like to avoid unnecessary casting.

I prefer to keep it decimal. The conversion routines expect decimal by default
and it requires less casting.

[Sergey Ulanov, 2013/08/08 18:22:37]

Yes, I was thinking about doing it without the prefix. I don't think it would be
less apparent that it's hex, and it should be in documentation anyway. This
reminds me that we also need to update documentation for this change. It's in
chrome/common/extensions/docs/templates/articles/messaging.html . Probably can
be done in a separate CL.
How are the handles signed? I thought HWND is just void*, no? So it shouldn't
matter if you reinterpret_cast<> them to intptr_t or uintptr_t.

It's not a problem with chromium, but it could be with some other libraries,
which, for example, may not handle '-' properly when parsing command line.
ok, let's keep it decimal.

[alexeypa (please no reviews), 2013/08/08 23:57:41]

Pointers are signed too. (void*)0xffffffff is smaller than (void*)0.
It does not matter if you are careful enough (on the platforms we care about).
It might matter in some subtle cases or exotic CPU architectures. For instance
it is "safe" to do |int64_t i = (int32_t)handle| on a 64bit Windows machine.
Despite the handles being pointers, their values are guaranteed to be 32bit for
backward compatibility. 

Basically my point is that it is safer to worry only about type sizes, than to
worry about both type sizes and whether a value can be represented by an
unsigned type.

[Sergey Ulanov, 2013/08/09 01:00:52]

AFAIK pointer ordering is undefined, so it depends on compiler. GCC seems to
compare them as unsigned values:

$ cat a.cc 
#include <iostream>

int main() {
  void* a = reinterpret_cast<void*>(-1LL);
  void* b = reinterpret_cast<void*>(0);
  if (a < b)
    std::cout << "a < b";
  else
    std::cout << "a >= b";
  std::cout << std::endl;
}
$ g++ a.cc
$ ./a.out 
a >= b

+#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::NativeWindow 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::NativeWindow native_view) {
+  return scoped_ptr<NativeProcessLauncher>(
+      new NativeProcessLauncherImpl(native_view));
 }
 
 }  // namespace extensions