text: // Copyright 2013 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/chrome_process_finder_win.h"
  
  #include <shellapi.h>
  #include <string>
  
  #include "base/command_line.h"
  #include "base/file_util.h"
  #include "base/files/file_path.h"
  #include "base/logging.h"
  #include "base/process/process_handle.h"
  #include "base/process/process_info.h"
  #include "base/strings/string_number_conversions.h"
  #include "base/strings/stringprintf.h"
  #include "base/strings/utf_string_conversions.h"
  #include "base/win/message_window.h"
  #include "base/win/metro.h"
  #include "base/win/scoped_handle.h"
  #include "base/win/win_util.h"
  #include "base/win/windows_version.h"
  #include "chrome/browser/metro_utils/metro_chrome_win.h"
  #include "chrome/common/chrome_constants.h"
  #include "chrome/common/chrome_switches.h"
  
  
  namespace {
  
  const int kTimeoutInSeconds = 20;
  
  // The following is copied from net/base/escape.cc. We don't want to depend on
  // net here because this gets compiled into chrome.exe to facilitate
  // fast-rendezvous (see https://codereview.chromium.org/14617003/).
  
  // TODO(koz): Move these functions out of net/base/escape.cc into base/escape.cc
  // so we can depend on it directly.
  
  // BEGIN COPY from net/base/escape.cc
  
  // A fast bit-vector map for ascii characters.
  //
  // Internally stores 256 bits in an array of 8 ints.
  // Does quick bit-flicking to lookup needed characters.
  struct Charmap {
    bool Contains(unsigned char c) const {
      return ((map[c >> 5] & (1 << (c & 31))) != 0);
    }
  
    uint32 map[8];
  };
  
  const char kHexString[] = "0123456789ABCDEF";
  inline char IntToHex(int i) {
    DCHECK_GE(i, 0) << i << " not a hex value";
    DCHECK_LE(i, 15) << i << " not a hex value";
    return kHexString[i];
  }
  
  // Given text to escape and a Charmap defining which values to escape,
  // return an escaped string.  If use_plus is true, spaces are converted
  // to +, otherwise, if spaces are in the charmap, they are converted to
  // %20.
  std::string Escape(const std::string& text, const Charmap& charmap,
                     bool use_plus) {
    std::string escaped;
    escaped.reserve(text.length() * 3);
    for (unsigned int i = 0; i < text.length(); ++i) {
      unsigned char c = static_cast<unsigned char>(text[i]);
      if (use_plus && ' ' == c) {
        escaped.push_back('+');
      } else if (charmap.Contains(c)) {
        escaped.push_back('%');
        escaped.push_back(IntToHex(c >> 4));
        escaped.push_back(IntToHex(c & 0xf));
      } else {
        escaped.push_back(c);
      }
    }
    return escaped;
  }
  
  // Everything except alphanumerics and !'()*-._~
  // See RFC 2396 for the list of reserved characters.
  static const Charmap kQueryCharmap = {{
    0xffffffffL, 0xfc00987dL, 0x78000001L, 0xb8000001L,
    0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
  }};
  
  std::string EscapeQueryParamValue(const std::string& text, bool use_plus) {
    return Escape(text, kQueryCharmap, use_plus);
  }
  
  // END COPY from net/base/escape.cc
  
  }  // namespace
  
  namespace chrome {
  
  HWND FindRunningChromeWindow(const base::FilePath& user_data_dir) {
    return base::win::MessageWindow::FindWindow(user_data_dir.value());
  }
  
  NotifyChromeResult AttemptToNotifyRunningChrome(HWND remote_window,
                                                  bool fast_start) {
    DCHECK(remote_window);
    static const char kSearchUrl[] =
        "http://www.google.com/search?q=%s&sourceid=chrome&ie=UTF-8";
    DWORD process_id = 0;
    DWORD thread_id = GetWindowThreadProcessId(remote_window, &process_id);
    if (!thread_id || !process_id)
      return NOTIFY_FAILED;
  
  #if !defined(USE_AURA)
    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.
      base::string16 terms;
      base::win::MetroLaunchType launch = base::win::GetMetroLaunchParams(&terms);
      if (launch != base::win::METRO_SEARCH) {
        LOG(WARNING) << "In metro mode, but and launch is " << launch;
      } else {
        std::string query = EscapeQueryParamValue(base::UTF16ToUTF8(terms), true);
        std::string url = base::StringPrintf(kSearchUrl, query.c_str());
        SHELLEXECUTEINFOA sei = { sizeof(sei) };
        sei.fMask = SEE_MASK_FLAG_LOG_USAGE;
        sei.nShow = SW_SHOWNORMAL;
        sei.lpFile = url.c_str();
        OutputDebugStringA(sei.lpFile);
        sei.lpDirectory = "";
        ::ShellExecuteExA(&sei);
      }
      return NOTIFY_SUCCESS;
    }
  
    base::win::ScopedHandle process_handle;
    if (base::win::GetVersion() >= base::win::VERSION_WIN8 &&
        base::OpenProcessHandleWithAccess(
            process_id, PROCESS_QUERY_INFORMATION,
            process_handle.Receive())) {
      // Receive() causes the process handle to be set in the destructor of the
      // temporary receiver object, which does not happen until after the if
      // statement is complete.  So IsProcessImmersive() should only be checked
      // as part of a separate if statement.
      if (base::win::IsProcessImmersive(process_handle.Get()))
        chrome::ActivateMetroChrome();
    }
  #endif
  
    CommandLine command_line(*CommandLine::ForCurrentProcess());
    command_line.AppendSwitchASCII(
        switches::kOriginalProcessStartTime,
        base::Int64ToString(
            base::CurrentProcessInfo::CreationTime().ToInternalValue()));
  
    if (fast_start)
      command_line.AppendSwitch(switches::kFastStart);
  
    // Send the command line to the remote chrome window.
    // Format is "START\0<<<current directory>>>\0<<<commandline>>>".
    std::wstring to_send(L"START\0", 6);  // want the NULL in the string.
    base::FilePath cur_dir;
    if (!file_util::GetCurrentDirectory(&cur_dir))
      return NOTIFY_FAILED;
    to_send.append(cur_dir.value());
    to_send.append(L"\0", 1);  // Null separator.
    to_send.append(command_line.GetCommandLineString());
    to_send.append(L"\0", 1);  // Null separator.
  
    // Allow the current running browser window to make itself the foreground
    // window (otherwise it will just flash in the taskbar).
    ::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,
                             reinterpret_cast<LPARAM>(&cds),
                             SMTO_ABORTIFHUNG,
                             kTimeoutInSeconds * 1000,
                             &result)) {
      return result ? NOTIFY_SUCCESS : NOTIFY_FAILED;
    }
  
    // It is possible that the process owning this window may have died by now.
    if (!::IsWindow(remote_window))
      return NOTIFY_FAILED;
  
    // If the window couldn't be notified but still exists, assume it is hung.
    return NOTIFY_WINDOW_HUNG;
  }
  
  }  // namespace chrome
  