1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/chrome_process_finder_win.h"
6
7 #include <shellapi.h>
8 #include <string>
9
10 #include "base/command_line.h"
11 #include "base/files/file_path.h"
12 #include "base/files/file_util.h"
13 #include "base/logging.h"
14 #include "base/process/process_handle.h"
15 #include "base/process/process_info.h"
16 #include "base/strings/string_number_conversions.h"
17 #include "base/strings/stringprintf.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "base/win/message_window.h"
20 #include "base/win/metro.h"
21 #include "base/win/scoped_handle.h"
22 #include "base/win/win_util.h"
23 #include "base/win/windows_version.h"
24 #include "chrome/browser/metro_utils/metro_chrome_win.h"
25 #include "chrome/common/chrome_constants.h"
26 #include "chrome/common/chrome_switches.h"
27
28
29 namespace {
30
31 const int kTimeoutInSeconds = 20;
32
33 // The following is copied from net/base/escape.cc. We don't want to depend on
34 // net here because this gets compiled into chrome.exe to facilitate
35 // fast-rendezvous (see https://codereview.chromium.org/14617003/).
36
37 // TODO(koz): Move these functions out of net/base/escape.cc into base/escape.cc
38 // so we can depend on it directly.
39
40 // BEGIN COPY from net/base/escape.cc
41
42 // A fast bit-vector map for ascii characters.
43 //
44 // Internally stores 256 bits in an array of 8 ints.
45 // Does quick bit-flicking to lookup needed characters.
46 struct Charmap {
Contains__anon57a8f9b60111::Charmap47 bool Contains(unsigned char c) const {
48 return ((map[c >> 5] & (1 << (c & 31))) != 0);
49 }
50
51 uint32 map[8];
52 };
53
54 const char kHexString[] = "0123456789ABCDEF";
IntToHex(int i)55 inline char IntToHex(int i) {
56 DCHECK_GE(i, 0) << i << " not a hex value";
57 DCHECK_LE(i, 15) << i << " not a hex value";
58 return kHexString[i];
59 }
60
61 // Given text to escape and a Charmap defining which values to escape,
62 // return an escaped string. If use_plus is true, spaces are converted
63 // to +, otherwise, if spaces are in the charmap, they are converted to
64 // %20.
Escape(const std::string & text,const Charmap & charmap,bool use_plus)65 std::string Escape(const std::string& text, const Charmap& charmap,
66 bool use_plus) {
67 std::string escaped;
68 escaped.reserve(text.length() * 3);
69 for (unsigned int i = 0; i < text.length(); ++i) {
70 unsigned char c = static_cast<unsigned char>(text[i]);
71 if (use_plus && ' ' == c) {
72 escaped.push_back('+');
73 } else if (charmap.Contains(c)) {
74 escaped.push_back('%');
75 escaped.push_back(IntToHex(c >> 4));
76 escaped.push_back(IntToHex(c & 0xf));
77 } else {
78 escaped.push_back(c);
79 }
80 }
81 return escaped;
82 }
83
84 // Everything except alphanumerics and !'()*-._~
85 // See RFC 2396 for the list of reserved characters.
86 static const Charmap kQueryCharmap = {{
87 0xffffffffL, 0xfc00987dL, 0x78000001L, 0xb8000001L,
88 0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
89 }};
90
EscapeQueryParamValue(const std::string & text,bool use_plus)91 std::string EscapeQueryParamValue(const std::string& text, bool use_plus) {
92 return Escape(text, kQueryCharmap, use_plus);
93 }
94
95 // END COPY from net/base/escape.cc
96
97 } // namespace
98
99 namespace chrome {
100
FindRunningChromeWindow(const base::FilePath & user_data_dir)101 HWND FindRunningChromeWindow(const base::FilePath& user_data_dir) {
102 return base::win::MessageWindow::FindWindow(user_data_dir.value());
103 }
104
AttemptToNotifyRunningChrome(HWND remote_window,bool fast_start)105 NotifyChromeResult AttemptToNotifyRunningChrome(HWND remote_window,
106 bool fast_start) {
107 DCHECK(remote_window);
108 static const char kSearchUrl[] =
109 "http://www.google.com/search?q=%s&sourceid=chrome&ie=UTF-8";
110 DWORD process_id = 0;
111 DWORD thread_id = GetWindowThreadProcessId(remote_window, &process_id);
112 if (!thread_id || !process_id)
113 return NOTIFY_FAILED;
114
115 #if !defined(USE_AURA)
116 if (base::win::IsMetroProcess()) {
117 // Interesting corner case. We are launched as a metro process but we
118 // found another chrome running. Since metro enforces single instance then
119 // the other chrome must be desktop chrome and this must be a search charm
120 // activation. This scenario is unique; other cases should be properly
121 // handled by the delegate_execute which will not activate a second chrome.
122 base::string16 terms;
123 base::win::MetroLaunchType launch = base::win::GetMetroLaunchParams(&terms);
124 if (launch != base::win::METRO_SEARCH) {
125 LOG(WARNING) << "In metro mode, but and launch is " << launch;
126 } else {
127 std::string query = EscapeQueryParamValue(base::UTF16ToUTF8(terms), true);
128 std::string url = base::StringPrintf(kSearchUrl, query.c_str());
129 SHELLEXECUTEINFOA sei = { sizeof(sei) };
130 sei.fMask = SEE_MASK_FLAG_LOG_USAGE;
131 sei.nShow = SW_SHOWNORMAL;
132 sei.lpFile = url.c_str();
133 OutputDebugStringA(sei.lpFile);
134 sei.lpDirectory = "";
135 ::ShellExecuteExA(&sei);
136 }
137 return NOTIFY_SUCCESS;
138 }
139
140 base::win::ScopedHandle process_handle;
141 if (base::win::GetVersion() >= base::win::VERSION_WIN8 &&
142 base::OpenProcessHandleWithAccess(
143 process_id, PROCESS_QUERY_INFORMATION,
144 process_handle.Receive())) {
145 // Receive() causes the process handle to be set in the destructor of the
146 // temporary receiver object, which does not happen until after the if
147 // statement is complete. So IsProcessImmersive() should only be checked
148 // as part of a separate if statement.
149 if (base::win::IsProcessImmersive(process_handle.Get()))
150 chrome::ActivateMetroChrome();
151 }
152 #endif
153
154 CommandLine command_line(*CommandLine::ForCurrentProcess());
155 command_line.AppendSwitchASCII(
156 switches::kOriginalProcessStartTime,
157 base::Int64ToString(
158 base::CurrentProcessInfo::CreationTime().ToInternalValue()));
159
160 if (fast_start)
161 command_line.AppendSwitch(switches::kFastStart);
162
163 // Send the command line to the remote chrome window.
164 // Format is "START\0<<<current directory>>>\0<<<commandline>>>".
165 std::wstring to_send(L"START\0", 6); // want the NULL in the string.
166 base::FilePath cur_dir;
167 if (!base::GetCurrentDirectory(&cur_dir))
168 return NOTIFY_FAILED;
169 to_send.append(cur_dir.value());
170 to_send.append(L"\0", 1); // Null separator.
171 to_send.append(command_line.GetCommandLineString());
172 to_send.append(L"\0", 1); // Null separator.
173
174 // Allow the current running browser window to make itself the foreground
175 // window (otherwise it will just flash in the taskbar).
176 ::AllowSetForegroundWindow(process_id);
177
178 COPYDATASTRUCT cds;
179 cds.dwData = 0;
180 cds.cbData = static_cast<DWORD>((to_send.length() + 1) * sizeof(wchar_t));
181 cds.lpData = const_cast<wchar_t*>(to_send.c_str());
182 DWORD_PTR result = 0;
183 if (::SendMessageTimeout(remote_window,
184 WM_COPYDATA,
185 NULL,
186 reinterpret_cast<LPARAM>(&cds),
187 SMTO_ABORTIFHUNG,
188 kTimeoutInSeconds * 1000,
189 &result)) {
190 return result ? NOTIFY_SUCCESS : NOTIFY_FAILED;
191 }
192
193 // It is possible that the process owning this window may have died by now.
194 if (!::IsWindow(remote_window))
195 return NOTIFY_FAILED;
196
197 // If the window couldn't be notified but still exists, assume it is hung.
198 return NOTIFY_WINDOW_HUNG;
199 }
200
201 } // namespace chrome
202