Implement forwarding of search queries for metro mode

chrome/browser/process_singleton_win.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/process_singleton.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/utf_string_conversions.h"
+#include "base/win/metro.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/wrapped_window_proc.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/wmi.h"
 #include "content/public/common/result_codes.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/win/hwnd_util.h"
@@ skipping 82 matching lines @@
 
     // Get command line.
     const std::wstring cmd_line =
         msg.substr(second_null + 1, third_null - second_null);
     *parsed_command_line = CommandLine::FromString(cmd_line);
     return true;
   }
   return false;
 }
 
+// Find any top level, visible chrome window. The name is fragile
+// but the file that defines the name warns against modification.
+BOOL CALLBACK TopWindowFinder(HWND hwnd, LPARAM result) {
+  char classname[128];
+  if (::GetClassNameA(hwnd, classname, arraysize(classname))) {
+    if (IsWindowVisible(hwnd)) {
+      if (lstrcmpiA("Chrome_WidgetWin_1", classname) == 0) {
+        *reinterpret_cast<HWND*>(result) = hwnd;
+        return FALSE;
+      }
+    }
+  }
+  return TRUE;
+}
+
 }  // namespace
 
 // Microsoft's Softricity virtualization breaks the sandbox processes.
 // So, if we detect the Softricity DLL we use WMI Win32_Process.Create to
 // break out of the virtualization environment.
 // http://code.google.com/p/chromium/issues/detail?id=43650
 bool ProcessSingleton::EscapeVirtualization(const FilePath& user_data_dir) {
   if (::GetModuleHandle(L"sftldr_wow64.dll") ||
       ::GetModuleHandle(L"sftldr.dll")) {
     int process_id;
@@ skipping 107 matching lines @@
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
   if (is_virtualized_)
     return PROCESS_NOTIFIED;  // We already spawned the process in this case.
   if (lock_file_ == INVALID_HANDLE_VALUE && !remote_window_)
     return LOCK_ERROR;
   else if (!remote_window_)
     return PROCESS_NONE;
 
-  // Found another window, send our command line to it
+  DWORD process_id = 0;
+  DWORD thread_id = GetWindowThreadProcessId(remote_window_, &process_id);
+  // It is possible that the process owning this window may have died by now.
+  if (!thread_id || !process_id) {
+    remote_window_ = NULL;
+    return PROCESS_NONE;
+  }
+
+  if (base::win::IsMetroProcess()) {
+    // Interesting corner case. We are launched as a metro process but we
+    // found another chrome running. Since metro enforces single instance then
+    // the other chrome must be desktop chrome and this must be a search charm
+    // activation. This scenario is unique; other cases should be properly
+    // handled by the delegate_execute which will not activate a second chrome.
+    string16 url;
+    base::win::MetroLaunchType launch = base::win::GetMetroLaunchParams(&url);
+    if (launch != base::win::METRO_SEARCH) {
+      LOG(WARNING) << "In metro mode, but and launch is " << launch;
+    } else {
+      // Need to find a top level window widget, the |remote_window_| does not
+      // handle the search navigation message.
+      HWND top_widget = NULL;
+      EnumThreadWindows(thread_id, &TopWindowFinder, LPARAM(&top_widget));
+      if (top_widget) {
+        UINT search_message =
+            RegisterWindowMessage(chrome::kMetroNavigationAndSearchMessage);
+        ATOM atom = GlobalAddAtomW(url.c_str());
+        PostMessage(top_widget, search_message, 0, atom);
+        LOG(INFO) << "Sent search term " << url;
+      } else {
+        LOG(WARNING) << "Could not find top level window";
+      }
+    }
+    return PROCESS_NOTIFIED;
+  }
+  // Non-metro mode, send our command line to the other chrome message window.
   // format is "START\0<<<current directory>>>\0<<<commandline>>>".
   std::wstring to_send(L"START\0", 6);  // want the NULL in the string.
   FilePath cur_dir;
   if (!PathService::Get(base::DIR_CURRENT, &cur_dir))
     return PROCESS_NONE;
   to_send.append(cur_dir.value());
   to_send.append(L"\0", 1);  // Null separator.
   to_send.append(GetCommandLineW());
   to_send.append(L"\0", 1);  // Null separator.
 
   // Allow the current running browser window making itself the foreground
   // window (otherwise it will just flash in the taskbar).
-  DWORD process_id = 0;
-  DWORD thread_id = GetWindowThreadProcessId(remote_window_, &process_id);
-  // It is possible that the process owning this window may have died by now.
-  if (!thread_id || !process_id) {
-    remote_window_ = NULL;
-    return PROCESS_NONE;
-  }
-
   AllowSetForegroundWindow(process_id);
 
   COPYDATASTRUCT cds;
   cds.dwData = 0;
   cds.cbData = static_cast<DWORD>((to_send.length() + 1) * sizeof(wchar_t));
   cds.lpData = const_cast<wchar_t*>(to_send.c_str());
   DWORD_PTR result = 0;
   if (SendMessageTimeout(remote_window_,
                          WM_COPYDATA,
                          NULL,
@@ skipping 98 matching lines @@
   switch (message) {
     case WM_COPYDATA:
       return OnCopyData(reinterpret_cast<HWND>(wparam),
                         reinterpret_cast<COPYDATASTRUCT*>(lparam));
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }