Add chrome to the repository.

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@15 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 844 insertions, 0 deletions

diff --git a/chrome/common/win_util.cc b/chrome/common/win_util.cc
new file mode 100644
index 0000000..8629b3ca
--- /dev/null
+++ b/chrome/common/win_util.cc
@@ -0,0 +1,844 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "chrome/common/win_util.h"
+
+#include <atlbase.h>
+#include <atlapp.h>
+#include <commdlg.h>
+#include <dwmapi.h>
+#include <shellapi.h>
+#include <shlobj.h>
+
+#include "base/file_util.h"
+#include "base/gfx/bitmap_header.h"
+#include "base/gfx/png_encoder.h"
+#include "base/logging.h"
+#include "base/registry.h"
+#include "base/scoped_handle.h"
+#include "base/string_util.h"
+#include "base/win_util.h"
+#include "chrome/common/l10n_util.h"
+#include "generated_resources.h"
+
+// Ensure that we pick up this link library.
+#pragma comment(lib, "dwmapi.lib")
+
+namespace win_util {
+
+namespace {
+
+// Enforce visible dialog box.
+UINT_PTR CALLBACK SaveAsDialogHook(HWND dialog, UINT message,
+                                   WPARAM wparam, LPARAM lparam) {
+  static const UINT kPrivateMessage = 0x2F3F;
+  switch (message) {
+    case WM_INITDIALOG: {
+      // Do nothing here. Just post a message to defer actual processing.
+      PostMessage(dialog, kPrivateMessage, 0, 0);
+      return TRUE;
+    }
+    case kPrivateMessage: {
+      // The dialog box is the parent of the current handle.
+      HWND real_dialog = GetParent(dialog);
+
+      // Retrieve the final size.
+      RECT dialog_rect;
+      GetWindowRect(real_dialog, &dialog_rect);
+
+      // Verify that the upper left corner is visible.
+      POINT point = { dialog_rect.left, dialog_rect.top };
+      HMONITOR monitor1 = MonitorFromPoint(point, MONITOR_DEFAULTTONULL);
+      point.x = dialog_rect.right;
+      point.y = dialog_rect.bottom;
+
+      // Verify that the lower right corner is visible.
+      HMONITOR monitor2 = MonitorFromPoint(point, MONITOR_DEFAULTTONULL);
+      if (monitor1 && monitor2)
+        return 0;
+
+      // Some part of the dialog box is not visible, fix it by moving is to the
+      // client rect position of the browser window.
+      HWND parent_window = GetParent(real_dialog);
+      if (!parent_window)
+        return 0;
+      WINDOWINFO parent_info;
+      parent_info.cbSize = sizeof(WINDOWINFO);
+      GetWindowInfo(parent_window, &parent_info);
+      SetWindowPos(real_dialog, NULL,
+                   parent_info.rcClient.left,
+                   parent_info.rcClient.top,
+                   0, 0,  // Size.
+                   SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE |
+                   SWP_NOZORDER);
+
+      return 0;
+    }
+  }
+  return 0;
+}
+
+}  // namespace
+
+std::wstring FormatSystemTime(const SYSTEMTIME& time,
+                              const std::wstring& format) {
+  // If the format string is empty, just use the default format.
+  LPCTSTR format_ptr = NULL;
+  if (!format.empty())
+    format_ptr = format.c_str();
+
+  int buffer_size = GetTimeFormat(LOCALE_USER_DEFAULT, NULL, &time, format_ptr,
+                                  NULL, 0);
+
+  std::wstring output;
+  GetTimeFormat(LOCALE_USER_DEFAULT, NULL, &time, format_ptr,
+                WriteInto(&output, buffer_size), buffer_size);
+
+  return output;
+}
+
+std::wstring FormatSystemDate(const SYSTEMTIME& date,
+                              const std::wstring& format) {
+  // If the format string is empty, just use the default format.
+  LPCTSTR format_ptr = NULL;
+  if (!format.empty())
+    format_ptr = format.c_str();
+
+  int buffer_size = GetDateFormat(LOCALE_USER_DEFAULT, NULL, &date, format_ptr,
+                                  NULL, 0);
+
+  std::wstring output;
+  GetDateFormat(LOCALE_USER_DEFAULT, NULL, &date, format_ptr,
+                WriteInto(&output, buffer_size), buffer_size);
+
+  return output;
+}
+
+bool ConvertToLongPath(const std::wstring& short_path, std::wstring* long_path) {
+  wchar_t long_path_buf[MAX_PATH];
+  DWORD return_value = GetLongPathName(short_path.c_str(), long_path_buf,
+                                       MAX_PATH);
+  if (return_value != 0 && return_value < MAX_PATH) {
+    *long_path = long_path_buf;
+    return true;
+  }
+
+  return false;
+}
+
+bool IsDoubleClick(const POINT& origin,
+                   const POINT& current,
+                   DWORD elapsed_time) {
+  // The CXDOUBLECLK and CYDOUBLECLK system metrics describe the width and
+  // height of a rectangle around the origin position, inside of which clicks
+  // within the double click time are considered double clicks.
+  return (elapsed_time <= GetDoubleClickTime()) &&
+      (abs(current.x - origin.x) <= (GetSystemMetrics(SM_CXDOUBLECLK) / 2)) &&
+      (abs(current.y - origin.y) <= (GetSystemMetrics(SM_CYDOUBLECLK) / 2));
+}
+
+bool IsDrag(const POINT& origin, const POINT& current) {
+  // The CXDRAG and CYDRAG system metrics describe the width and height of a
+  // rectangle around the origin position, inside of which motion is not
+  // considered a drag.
+  return (abs(current.x - origin.x) > (GetSystemMetrics(SM_CXDRAG) / 2)) ||
+         (abs(current.y - origin.y) > (GetSystemMetrics(SM_CYDRAG) / 2));
+}
+
+bool ShouldUseVistaFrame() {
+  if (win_util::GetWinVersion() < win_util::WINVERSION_VISTA)
+    return false;
+  // If composition is not enabled, we behave like on XP.
+  BOOL f;
+  DwmIsCompositionEnabled(&f);
+  return !!f;
+}
+
+std::wstring FormatMessage(unsigned messageid) {
+  wchar_t * string_buffer = NULL;
+  unsigned string_length = ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                                      FORMAT_MESSAGE_FROM_SYSTEM |
+                                      FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+                                      messageid, 0,
+                                      reinterpret_cast<wchar_t *>(&string_buffer),
+                                      0, NULL);
+
+  std::wstring formatted_string;
+  if (string_buffer) {
+    formatted_string = string_buffer;
+    LocalFree(reinterpret_cast<HLOCAL>(string_buffer));
+  } else {
+    // The formating failed. simply convert the message value into a string.
+    SStringPrintf(&formatted_string, L"message number %d", messageid);
+  }
+  return formatted_string;
+}
+
+std::wstring FormatLastWin32Error() {
+  return FormatMessage(GetLastError());
+}
+
+void ShowItemInFolder(const std::wstring& full_path) {
+  std::wstring dir = file_util::GetDirectoryFromPath(full_path);
+  if (dir == L"" || !file_util::PathExists(full_path))
+    return;
+
+  typedef HRESULT (WINAPI *SHOpenFolderAndSelectItemsFuncPtr)(
+              PCIDLIST_ABSOLUTE pidl_Folder,
+              UINT cidl,
+              PCUITEMID_CHILD_ARRAY pidls,
+              DWORD flags);
+
+  static SHOpenFolderAndSelectItemsFuncPtr open_folder_and_select_itemsPtr = NULL;
+  static bool initialize_open_folder_proc = true;
+  if (initialize_open_folder_proc) {
+    initialize_open_folder_proc = false;
+    // The SHOpenFolderAndSelectItems API is exposed by shell32 version 6
+    // and does not exist in Win2K. We attempt to retrieve this function export
+    // from shell32 and if it does not exist, we just invoke ShellExecute to
+    // open the folder thus losing the functionality to select the item in
+    // the process.
+    HMODULE shell32_base = GetModuleHandle(L"shell32.dll");
+    if (!shell32_base) {
+      NOTREACHED();
+      return;
+    }
+    open_folder_and_select_itemsPtr =
+        reinterpret_cast<SHOpenFolderAndSelectItemsFuncPtr>
+            (GetProcAddress(shell32_base, "SHOpenFolderAndSelectItems"));
+  }
+  if (!open_folder_and_select_itemsPtr) {
+    ShellExecute(NULL, _T("open"), dir.c_str(), NULL, NULL, SW_SHOW);
+    return;
+  }
+
+  CComPtr<IShellFolder> desktop;
+  HRESULT hr = SHGetDesktopFolder(&desktop);
+  if (FAILED(hr))
+    return;
+
+  CoMemReleaser<ITEMIDLIST> dir_item;
+  hr = desktop->ParseDisplayName(NULL, NULL,
+                                 const_cast<wchar_t *>(dir.c_str()),
+                                 NULL, &dir_item, NULL);
+  if (FAILED(hr))
+    return;
+
+  CoMemReleaser<ITEMIDLIST> file_item;
+  hr = desktop->ParseDisplayName(NULL, NULL,
+                                 const_cast<wchar_t *>(full_path.c_str()),
+                                 NULL, &file_item, NULL);
+  if (FAILED(hr))
+    return;
+
+  const ITEMIDLIST* highlight[] = {
+    {file_item},
+  };
+  (*open_folder_and_select_itemsPtr)(dir_item, arraysize(highlight),
+                                     highlight, NULL);
+}
+
+// Open an item via a shell execute command. Error code checking and casting
+// explanation: http://msdn2.microsoft.com/en-us/library/ms647732.aspx
+bool OpenItemViaShell(const std::wstring& full_path, bool ask_for_app) {
+  HINSTANCE h = ::ShellExecuteW(NULL, NULL, full_path.c_str(), NULL,
+                                NULL, SW_SHOWNORMAL);
+  LONG_PTR error = reinterpret_cast<LONG_PTR>(h);
+  if (error > 32)
+    return true;
+
+  if ((error == SE_ERR_NOASSOC) && ask_for_app)
+    return OpenItemWithExternalApp(full_path);
+
+  return false;
+}
+
+bool OpenItemViaShellNoZoneCheck(const std::wstring& full_path,
+                                 bool ask_for_app) {
+  SHELLEXECUTEINFO sei = { sizeof(sei) };
+  sei.fMask = SEE_MASK_NOZONECHECKS | SEE_MASK_FLAG_DDEWAIT;
+  sei.nShow = SW_SHOWNORMAL;
+  sei.lpVerb = NULL;
+  sei.lpFile = full_path.c_str();
+  if (::ShellExecuteExW(&sei))
+    return true;
+  LONG_PTR error = reinterpret_cast<LONG_PTR>(sei.hInstApp);
+  if ((error == SE_ERR_NOASSOC) && ask_for_app)
+    return OpenItemWithExternalApp(full_path);
+  return false;
+}
+
+// Show the Windows "Open With" dialog box to ask the user to pick an app to
+// open the file with.
+bool OpenItemWithExternalApp(const std::wstring& full_path) {
+  SHELLEXECUTEINFO sei = { sizeof(sei) };
+  sei.fMask = SEE_MASK_FLAG_DDEWAIT;
+  sei.nShow = SW_SHOWNORMAL;
+  sei.lpVerb = L"openas";
+  sei.lpFile = full_path.c_str();
+  return (TRUE == ::ShellExecuteExW(&sei));
+}
+
+// Get the file type description from the registry. This will be "Text Document"
+// for .txt files, "JPEG Image" for .jpg files, etc. If the registry doesn't
+// have an entry for the file type, we return false, true if the description was
+// found. 'file_ext' must be in form ".txt".
+static bool GetRegistryDescriptionFromExtension(const std::wstring& file_ext,
+                                                std::wstring* reg_description) {
+  DCHECK(reg_description);
+  RegKey reg_ext(HKEY_CLASSES_ROOT, file_ext.c_str(), KEY_READ);
+  std::wstring reg_app;
+  if (reg_ext.ReadValue(NULL, &reg_app) && !reg_app.empty()) {
+    RegKey reg_link(HKEY_CLASSES_ROOT, reg_app.c_str(), KEY_READ);
+    if (reg_link.ReadValue(NULL, reg_description))
+      return true;
+  }
+  return false;
+}
+
+// Set up a filter for a "Save As" dialog, which will consist of 'file_ext' file
+// extension, 'ext_desc' as the text description of the 'file_ext' type, and
+// (optionally) the default 'All Files' view. The purpose of the filter is to
+// show only files of a particular type in a Windows "Save As" dialog box. The
+// resulting filter is stored in 'buffer', which is a vector since multiple
+// NULLs are embedded. The  filters created here are:
+//   1. only files that have 'file_ext' as their extension
+//   2. all files (only added if 'include_all_files' is true)
+// Example:
+//   file_ext: ".txt"
+//   ext_desc: "Text Document"
+//   returned (in buffer): "Text Document\0*.txt\0All Files\0*.*\0\0"
+// This is painful to build, as you will soon see.
+static void FormatSaveAsFilterForExtension(const std::wstring& file_ext,
+                                           const std::wstring& ext_desc,
+                                           bool include_all_files,
+                                           std::vector<wchar_t>* buffer) {
+  DCHECK(buffer);
+
+  // Force something reasonable to appear in the dialog box if there is no
+  // description provided.
+  if (file_ext.empty() || ext_desc.empty())
+    include_all_files = true;
+
+  size_t size;
+  size_t offset = 0;
+  const std::wstring all_ext = L"*.*";
+  const std::wstring all_desc = l10n_util::GetString(IDS_SAVEAS_ALL_FILES);
+
+  // Includes 2 internal NULLs + "*".
+  const size_t ext_size = ext_desc.length() + file_ext.length() + 3;
+  // Includes 2 internal NULLs.
+  const size_t all_size = all_desc.length() + all_ext.length() + 2;
+  // Includes double terminating NULL.
+  const size_t buf_size = (!ext_desc.empty() ? ext_size : 0) +
+                          (include_all_files ? all_size : 0) + 1;
+  buffer->resize(buf_size);
+
+  if (!file_ext.empty() && !ext_desc.empty()) {
+    // Copy in the text description ("JPEG Image") + NULL.
+    size = ext_desc.length() + 1;
+    memcpy(&(*buffer)[offset], ext_desc.c_str(), size * sizeof(wchar_t));
+    offset += size;
+
+    // Copy in the file type ("*.jpg") + NULL.
+    const std::wstring wildcard_ext = L"*" + file_ext;
+    size = wildcard_ext.length() + 1;
+    memcpy(&(*buffer)[offset], wildcard_ext.c_str(), size * sizeof(wchar_t));
+    offset += size;
+  }
+
+  if (include_all_files) {
+    // Copy in the default description ("All Files") + NULL.
+    size = all_desc.length() + 1;
+    memcpy(&(*buffer)[offset], all_desc.c_str(), size * sizeof(wchar_t));
+    offset += size;
+
+    // Copy in the default file extension ("*.*") + NULL.
+    size = all_ext.length() + 1;
+    memcpy(&(*buffer)[offset], all_ext.c_str(), size * sizeof(wchar_t));
+    offset += size;
+  }
+
+  (*buffer)[offset] = L'\0';  // Double NULL required.
+}
+
+bool SaveFileAs(HWND owner,
+                const std::wstring& suggested_name,
+                std::wstring* final_name) {
+  std::wstring reg_description;
+  std::wstring file_ext = file_util::GetFileExtensionFromPath(suggested_name);
+  if (!file_ext.empty()) {
+    file_ext = L"." + file_ext;
+    GetRegistryDescriptionFromExtension(file_ext, &reg_description);
+  }
+
+  std::vector<wchar_t> filter;
+  FormatSaveAsFilterForExtension(file_ext, reg_description, true, &filter);
+
+  unsigned index = 1;
+  return SaveFileAsWithFilter(owner,
+                              suggested_name,
+                              &filter[0],
+                              L"",
+                              &index,
+                              final_name);
+}
+
+bool SaveFileAsWithFilter(HWND owner,
+                          const std::wstring& suggested_name,
+                          const wchar_t* filter,
+                          const std::wstring& def_ext,
+                          unsigned* index,
+                          std::wstring* final_name) {
+  DCHECK(final_name);
+
+  // Initially populated by the file component of 'suggested_name', this buffer
+  // will be written into by Windows when the user is done with the dialog box.
+  wchar_t file_name[MAX_PATH+1];
+  std::wstring file_part = file_util::GetFilenameFromPath(suggested_name);
+  memcpy(file_name,
+         file_part.c_str(),
+         (file_part.length()+1) * sizeof(wchar_t));
+
+  OPENFILENAME save_as;
+  // We must do this otherwise the ofn's FlagsEx may be initialized to random
+  // junk in release builds which can cause the Places Bar not to show up!
+  ZeroMemory(&save_as, sizeof(save_as));
+  save_as.lStructSize = sizeof(OPENFILENAME);
+  save_as.hwndOwner = owner;
+  save_as.hInstance = NULL;
+
+  save_as.lpstrFilter = &filter[0];
+
+  save_as.lpstrCustomFilter = NULL;
+  save_as.nMaxCustFilter = 0;
+  save_as.nFilterIndex = *index;
+  save_as.lpstrFile = file_name;
+  save_as.nMaxFile = arraysize(file_name);
+  save_as.lpstrFileTitle = NULL;
+  save_as.nMaxFileTitle = 0;
+
+  // Set up the initial directory for the dialog.
+  std::wstring directory = file_util::GetDirectoryFromPath(suggested_name);
+  save_as.lpstrInitialDir = directory.c_str();
+  save_as.lpstrTitle = NULL;
+  save_as.Flags = OFN_OVERWRITEPROMPT | OFN_EXPLORER | OFN_ENABLESIZING |
+                  OFN_ENABLEHOOK | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST;
+  save_as.lpstrDefExt = &def_ext[0];
+  save_as.lCustData = NULL;
+  save_as.lpfnHook = &SaveAsDialogHook;
+
+  // Must be NULL or 0.
+  save_as.pvReserved = NULL;
+  save_as.dwReserved = 0;
+
+  if (!GetSaveFileName(&save_as))
+    return false;
+
+  // Return the user's choice.
+  final_name->assign(save_as.lpstrFile);
+  *index = save_as.nFilterIndex;
+
+  std::wstring file_ext = file_util::GetFileExtensionFromPath(suggested_name);
+  if (save_as.nFileExtension == 0) {
+    // No extension is specified. Append the default extension.
+    final_name->append(file_ext);
+  } else if (save_as.nFileExtension == wcslen(save_as.lpstrFile)) {
+    // The path ends with a ".". This is not supported on windows and since
+    // we don't use a windows API to create the file, it will make the file
+    // impossible to open.
+    final_name->resize(final_name->size() - 1);
+  }
+
+  return true;
+}
+
+// Adjust the window to fit, returning true if the window was resized or moved.
+static bool AdjustWindowToFit(HWND hwnd, const RECT& bounds) {
+  // Get the monitor.
+  HMONITOR hmon = MonitorFromRect(&bounds, MONITOR_DEFAULTTONEAREST);
+  if (!hmon) {
+    NOTREACHED() << "Unable to find default monitor";
+    // No monitor available.
+    return false;
+  }
+
+  MONITORINFO mi;
+  mi.cbSize = sizeof(mi);
+  GetMonitorInfo(hmon, &mi);
+  gfx::Rect window_rect(bounds);
+  gfx::Rect monitor_rect(mi.rcWork);
+  gfx::Rect new_window_rect = window_rect.AdjustToFit(monitor_rect);
+  if (!new_window_rect.Equals(window_rect)) {
+    // Window doesn't fit on monitor, move and possibly resize.
+    SetWindowPos(hwnd, 0, new_window_rect.x(), new_window_rect.y(),
+                 new_window_rect.width(), new_window_rect.height(),
+                 SWP_NOACTIVATE | SWP_NOZORDER);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void AdjustWindowToFit(HWND hwnd) {
+  // Get the window bounds.
+  RECT r;
+  GetWindowRect(hwnd, &r);
+  AdjustWindowToFit(hwnd, r);
+}
+
+void CenterAndSizeWindow(HWND parent, HWND window, const SIZE& pref,
+                         bool pref_is_client) {
+  DCHECK(window && pref.cx > 0 && pref.cy > 0);
+  // Calculate the ideal bounds.
+  RECT window_bounds;
+  RECT center_bounds = {0};
+  if (parent) {
+    // If there is a parent, center over the parents bounds.
+    ::GetWindowRect(parent, &center_bounds);
+  } else {
+    // No parent. Center over the monitor the window is on.
+    HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST);
+    if (monitor) {
+      MONITORINFO mi = {0};
+      mi.cbSize = sizeof(mi);
+      GetMonitorInfo(monitor, &mi);
+      center_bounds = mi.rcWork;
+    } else {
+      NOTREACHED() << "Unable to get default monitor";
+    }
+  }
+  window_bounds.left = center_bounds.left +
+                       (center_bounds.right - center_bounds.left - pref.cx) / 2;
+  window_bounds.right = window_bounds.left + pref.cx;
+  window_bounds.top = center_bounds.top +
+                      (center_bounds.bottom - center_bounds.top - pref.cy) / 2;
+  window_bounds.bottom = window_bounds.top + pref.cy;
+
+  // If we're centering a child window, we are positioning in client
+  // coordinates, and as such we need to offset the target rectangle by the
+  // position of the parent window.
+  if (::GetWindowLong(window, GWL_STYLE) & WS_CHILD) {
+    DCHECK(parent && ::GetParent(window) == parent);
+    POINT topleft = { window_bounds.left, window_bounds.top };
+    ::MapWindowPoints(HWND_DESKTOP, parent, &topleft, 1);
+    window_bounds.left = topleft.x;
+    window_bounds.top = topleft.y;
+    window_bounds.right = window_bounds.left + pref.cx;
+    window_bounds.bottom = window_bounds.top + pref.cy;
+  }
+
+  // Get the WINDOWINFO for window. We need the style to calculate the size
+  // for the window.
+  WINDOWINFO win_info = {0};
+  win_info.cbSize = sizeof(WINDOWINFO);
+  GetWindowInfo(window, &win_info);
+
+  // Calculate the window size needed for the content size.
+
+  if (!pref_is_client ||
+      AdjustWindowRectEx(&window_bounds, win_info.dwStyle, FALSE,
+                         win_info.dwExStyle)) {
+    if (!AdjustWindowToFit(window, window_bounds)) {
+      // The window fits, reset the bounds.
+      SetWindowPos(window, 0, window_bounds.left, window_bounds.top,
+                   window_bounds.right - window_bounds.left,
+                   window_bounds.bottom - window_bounds.top,
+                   SWP_NOACTIVATE | SWP_NOZORDER);
+    }  // else case, AdjustWindowToFit set the bounds for us.
+  } else {
+    NOTREACHED() << "Unable to adjust window to fit";
+  }
+}
+
+HANDLE GetSectionFromProcess(HANDLE section, HANDLE process, bool read_only) {
+  HANDLE valid_section = NULL;
+  DWORD access = STANDARD_RIGHTS_REQUIRED | FILE_MAP_READ;
+  if (!read_only)
+    access |= FILE_MAP_WRITE;
+  DuplicateHandle(process, section, GetCurrentProcess(), &valid_section, access,
+                  FALSE, 0);
+  return valid_section;
+}
+
+bool DoesWindowBelongToActiveWindow(HWND window) {
+  DCHECK(window);
+  HWND top_window = ::GetAncestor(window, GA_ROOT);
+  if (!top_window)
+    return false;
+
+  HWND active_top_window = ::GetAncestor(::GetForegroundWindow(), GA_ROOT);
+  return (top_window == active_top_window);
+}
+
+void EnsureRectIsVisibleInRect(const gfx::Rect& parent_rect,
+                               gfx::Rect* child_rect,
+                               int padding) {
+  DCHECK(child_rect);
+
+  // We use padding here because it allows some of the original web page to
+  // bleed through around the edges.
+  int twice_padding = padding * 2;
+
+  // FIRST, clamp width and height so we don't open child windows larger than
+  // the containing parent.
+  if (child_rect->width() > (parent_rect.width() + twice_padding))
+    child_rect->set_width(std::max(0, parent_rect.width() - twice_padding));
+  if (child_rect->height() > parent_rect.height() + twice_padding)
+    child_rect->set_height(std::max(0, parent_rect.height() - twice_padding));
+
+  // SECOND, clamp x,y position to padding,padding so we don't position child
+  // windows in hyperspace.
+  if (child_rect->x() < 0 || child_rect->x() > parent_rect.width())
+    child_rect->set_x(padding);
+  if (child_rect->y() < 0 || child_rect->y() > parent_rect.height())
+    child_rect->set_y(padding);
+
+  // LAST, nudge the window back up into the client area if its x,y position is
+  // within the parent bounds but its width/height place it off-screen.
+  if (child_rect->bottom() > parent_rect.bottom())
+    child_rect->set_y(parent_rect.bottom() - child_rect->height() - padding);
+  if (child_rect->right() > parent_rect.right())
+    child_rect->set_x(parent_rect.right() - child_rect->width() - padding);
+}
+
+void SetChildBounds(HWND child_window, HWND parent_window,
+                    HWND insert_after_window, const gfx::Rect& bounds,
+                    int padding, unsigned long flags) {
+  DCHECK(IsWindow(child_window));
+
+  // First figure out the bounds of the parent.
+  RECT parent_rect = {0};
+  if (parent_window) {
+    GetClientRect(parent_window, &parent_rect);
+  } else {
+    // If there is no parent, we consider the bounds of the monitor the window
+    // is on to be the parent bounds.
+
+    // If the child_window isn't visible yet and we've been given a valid,
+    // visible insert after window, use that window to locate the correct
+    // monitor instead.
+    HWND window = child_window;
+    if (!IsWindowVisible(window) && IsWindow(insert_after_window) &&
+        IsWindowVisible(insert_after_window))
+      window = insert_after_window;
+
+    HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST);
+    if (monitor) {
+      MONITORINFO mi = {0};
+      mi.cbSize = sizeof(mi);
+      GetMonitorInfo(monitor, &mi);
+      parent_rect = mi.rcWork;
+    } else {
+      NOTREACHED() << "Unable to get default monitor";
+    }
+  }
+
+  gfx::Rect actual_bounds = bounds;
+  EnsureRectIsVisibleInRect(gfx::Rect(parent_rect), &actual_bounds, padding);
+
+  SetWindowPos(child_window, insert_after_window, actual_bounds.x(),
+               actual_bounds.y(), actual_bounds.width(),
+               actual_bounds.height(), flags);
+}
+
+gfx::Rect GetMonitorBoundsForRect(const gfx::Rect& rect) {
+  RECT p_rect = rect.ToRECT();
+  HMONITOR monitor = MonitorFromRect(&p_rect, MONITOR_DEFAULTTONEAREST);
+  if (monitor) {
+    MONITORINFO mi = {0};
+    mi.cbSize = sizeof(mi);
+    GetMonitorInfo(monitor, &mi);
+    return gfx::Rect(mi.rcWork);
+  }
+  NOTREACHED();
+  return gfx::Rect();
+}
+
+bool IsNumPadDigit(int key_code, bool extended_key) {
+  if (key_code >= VK_NUMPAD0 && key_code <= VK_NUMPAD9)
+    return true;
+
+  // Check for num pad keys without Num Lock.
+  // Note: there is no easy way to know if a the key that was pressed comes from
+  //       the num pad or the rest of the keyboard.  Investigating how
+  //       TranslateMessage() generates the WM_KEYCHAR from an
+  //       ALT + <numpad sequences> it appears it looks at the extended key flag
+  //       (which is on if the key pressed comes from one of the 3 clusters to
+  //       the left of the numeric keypad).  So we use it as well.
+  return !extended_key &&
+            ((key_code >= VK_PRIOR && key_code <= VK_DOWN) ||  // All keys but 5
+                                                               // and 0.
+            (key_code == VK_CLEAR) ||  // Key 5.
+            (key_code == VK_INSERT));  // Key 0.
+}
+
+void GrabWindowSnapshot(HWND window_handle,
+                        std::vector<unsigned char>* png_representation) {
+  // Create a memory DC that's compatible with the window.
+  CWindowDC window_hdc(window_handle);
+  CDC mem_hdc(::CreateCompatibleDC(window_hdc));
+
+  // Create a DIB that's the same size as the window.
+  RECT content_rect = {0, 0, 0, 0};
+  ::GetWindowRect(window_handle, &content_rect);
+  content_rect.right++;  // Match what PrintWindow wants.
+  int width = content_rect.right - content_rect.left;
+  int height = content_rect.bottom - content_rect.top;
+  BITMAPINFOHEADER hdr;
+  gfx::CreateBitmapHeader(width, height, &hdr);
+  unsigned char *bit_ptr = NULL;
+  CBitmap bitmap(::CreateDIBSection(mem_hdc,
+                                    reinterpret_cast<BITMAPINFO*>(&hdr),
+                                    DIB_RGB_COLORS,
+                                    reinterpret_cast<void **>(&bit_ptr),
+                                    NULL, 0));
+
+  mem_hdc.SelectBitmap(bitmap);
+  // Clear the bitmap to white (so that rounded corners on windows
+  // show up on a white background, and strangely-shaped windows
+  // look reasonable). Not capturing an alpha mask saves a
+  // bit of space.
+  mem_hdc.PatBlt(0, 0, width, height, WHITENESS);
+  // Grab a copy of the window
+  // First, see if PrintWindow is defined (it's not in Windows 2000).
+  typedef BOOL (WINAPI *PrintWindowPointer)(HWND, HDC, UINT);
+  PrintWindowPointer print_window =
+      reinterpret_cast<PrintWindowPointer>(
+          GetProcAddress(GetModuleHandle(L"User32.dll"), "PrintWindow"));
+
+  // If PrintWindow is defined, use it.  It will work on partially
+  // obscured windows, and works better for out of process sub-windows.
+  // Otherwise grab the bits we can get with BitBlt; it's better
+  // than nothing and will work fine in the average case (window is
+  // completely on screen).
+  if (print_window)
+    (*print_window)(window_handle, mem_hdc, 0);
+  else
+    mem_hdc.BitBlt(0, 0, width, height, window_hdc, 0, 0, SRCCOPY);
+
+  // We now have a copy of the window contents in a DIB, so
+  // encode it into a useful format for posting to the bug report
+  // server.
+  PNGEncoder::Encode(bit_ptr, PNGEncoder::FORMAT_BGRA,
+                     width, height, width * 4, true,
+                     png_representation);
+}
+
+bool IsWindowActive(HWND hwnd) {
+  WINDOWINFO info;
+  return ::GetWindowInfo(hwnd, &info) &&
+         ((info.dwWindowStatus & WS_ACTIVECAPTION) != 0);
+}
+
+bool IsReservedName(const std::wstring& filename) {
+  // This list is taken from the MSDN article "Naming a file"
+  // http://msdn2.microsoft.com/en-us/library/aa365247(VS.85).aspx
+  // I also added clock$ because GetSaveFileName seems to consider it as a
+  // reserved name too.
+  static const wchar_t* const known_devices[] = {
+    L"con", L"prn", L"aux", L"nul", L"com1", L"com2", L"com3", L"com4", L"com5",
+    L"com6", L"com7", L"com8", L"com9", L"lpt1", L"lpt2", L"lpt3", L"lpt4",
+    L"lpt5", L"lpt6", L"lpt7", L"lpt8", L"lpt9", L"clock$"
+  };
+  std::wstring filename_lower = StringToLowerASCII(filename);
+
+  for (int i = 0; i < arraysize(known_devices); ++i) {
+    // Exact match.
+    if (filename_lower == known_devices[i])
+      return true;
+    // Starts with "DEVICE.".
+    if (filename_lower.find(std::wstring(known_devices[i]) + L".") == 0)
+      return true;
+  }
+
+  static const wchar_t* const magic_names[] = {
+    // These file names are used by the "Customize folder" feature of the shell.
+    L"desktop.ini",
+    L"thumbs.db",
+  };
+
+  for (int i = 0; i < arraysize(magic_names); ++i) {
+    if (filename_lower == magic_names[i])
+      return true;
+  }
+
+  return false;
+}
+
+bool IsShellIntegratedExtension(const std::wstring& extension) {
+  std::wstring extension_lower = StringToLowerASCII(extension);
+
+  static const wchar_t* const integrated_extensions[] = {
+    // See <http://msdn.microsoft.com/en-us/library/ms811694.aspx>.
+    L"local",
+    // Right-clicking on shortcuts can be magical.
+    L"lnk",
+  };
+
+  for (int i = 0; i < arraysize(integrated_extensions); ++i) {
+    if (extension_lower == integrated_extensions[i])
+      return true;
+  }
+
+  // See <http://www.juniper.net/security/auto/vulnerabilities/vuln2612.html>.
+  // That vulnerability report is not exactly on point, but files become magical
+  // if their end in a CLSID.  Here we block extensions that look like CLSIDs.
+  if (extension_lower.size() > 0 && extension_lower.at(0) == L'{' &&
+      extension_lower.at(extension_lower.length() - 1) == L'}')
+    return true;
+
+  return false;
+}
+
+// In addition to passing the RTL flags to ::MessageBox if we are running in an
+// RTL locale, we need to make sure that LTR strings are rendered correctly by
+// adding the appropriate Unicode directionality marks.
+int MessageBox(HWND hwnd,
+               const std::wstring& text,
+               const std::wstring& caption,
+               UINT flags) {
+  UINT actual_flags = flags;
+  if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT)
+    actual_flags |= MB_RIGHT | MB_RTLREADING;
+
+  std::wstring localized_text;
+  const wchar_t* text_ptr = text.c_str();
+  if (l10n_util::AdjustStringForLocaleDirection(text, &localized_text))
+    text_ptr = localized_text.c_str();
+
+  std::wstring localized_caption;
+  const wchar_t* caption_ptr = caption.c_str();
+  if (l10n_util::AdjustStringForLocaleDirection(caption, &localized_caption))
+    caption_ptr = localized_caption.c_str();
+
+  return ::MessageBox(hwnd, text_ptr, caption_ptr, actual_flags);
+}
+
+}  // namespace win_util