Remove some code inside USE_AURA and OS_WIN ifdefs.

content/browser/renderer_host/render_widget_host_view_win.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.

[scottmg, 2014/01/14 17:28:33]

BOOM

-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/browser/renderer_host/render_widget_host_view_win.h"
-
-#include <InputScope.h>
-#include <wtsapi32.h>
-#pragma comment(lib, "wtsapi32.lib")
-
-#include <algorithm>
-#include <map>
-#include <stack>
-
-#include "base/basictypes.h"
-#include "base/bind.h"
-#include "base/callback_helpers.h"
-#include "base/command_line.h"
-#include "base/debug/trace_event.h"
-#include "base/i18n/rtl.h"
-#include "base/metrics/histogram.h"
-#include "base/threading/thread.h"
-#include "base/win/metro.h"
-#include "base/win/scoped_comptr.h"
-#include "base/win/scoped_gdi_object.h"
-#include "base/win/win_util.h"
-#include "base/win/windows_version.h"
-#include "base/win/wrapped_window_proc.h"
-#include "content/browser/accessibility/browser_accessibility_manager_win.h"
-#include "content/browser/accessibility/browser_accessibility_state_impl.h"
-#include "content/browser/accessibility/browser_accessibility_win.h"
-#include "content/browser/gpu/gpu_data_manager_impl.h"
-#include "content/browser/gpu/gpu_process_host.h"
-#include "content/browser/gpu/gpu_process_host_ui_shim.h"
-#include "content/browser/renderer_host/backing_store.h"
-#include "content/browser/renderer_host/backing_store_win.h"
-#include "content/browser/renderer_host/input/web_input_event_builders_win.h"
-#include "content/browser/renderer_host/render_process_host_impl.h"
-#include "content/browser/renderer_host/render_widget_host_impl.h"
-#include "content/browser/renderer_host/ui_events_helper.h"
-#include "content/common/accessibility_messages.h"
-#include "content/common/gpu/gpu_messages.h"
-#include "content/common/plugin_constants_win.h"
-#include "content/common/view_messages.h"
-#include "content/common/webplugin_geometry.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/child_process_data.h"
-#include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/native_web_keyboard_event.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_types.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/common/content_switches.h"
-#include "content/public/common/page_zoom.h"
-#include "content/public/common/process_type.h"
-#include "skia/ext/skia_utils_win.h"
-#include "third_party/WebKit/public/web/WebCompositionUnderline.h"
-#include "third_party/WebKit/public/web/WebInputEvent.h"
-#include "third_party/skia/include/core/SkRegion.h"
-#include "ui/base/ime/composition_text.h"
-#include "ui/base/ime/win/imm32_manager.h"
-#include "ui/base/ime/win/tsf_input_scope.h"
-#include "ui/base/l10n/l10n_util_win.h"
-#include "ui/base/touch/touch_device.h"
-#include "ui/base/touch/touch_enabled.h"
-#include "ui/base/ui_base_switches.h"
-#include "ui/base/view_prop.h"
-#include "ui/base/win/mouse_wheel_util.h"
-#include "ui/base/win/touch_input.h"
-#include "ui/events/event.h"
-#include "ui/events/event_utils.h"
-#include "ui/gfx/canvas.h"
-#include "ui/gfx/rect.h"
-#include "ui/gfx/rect_conversions.h"
-#include "ui/gfx/screen.h"
-#include "ui/gfx/sequential_id_generator.h"
-#include "ui/gfx/text_elider.h"
-#include "ui/gfx/win/dpi.h"
-#include "ui/gfx/win/hwnd_util.h"
-#include "webkit/common/cursors/webcursor.h"
-#include "win8/util/win8_util.h"
-
-using base::TimeDelta;
-using base::TimeTicks;
-using ui::ViewProp;
-using blink::WebInputEvent;
-using blink::WebMouseEvent;
-using blink::WebTextDirection;
-
-namespace content {
-namespace {
-
-// Tooltips will wrap after this width. Yes, wrap. Imagine that!
-const int kTooltipMaxWidthPixels = 300;
-
-// Maximum number of characters we allow in a tooltip.
-const int kMaxTooltipLength = 1024;
-
-// A custom MSAA object id used to determine if a screen reader is actively
-// listening for MSAA events.
-const int kIdCustom = 1;
-
-// The delay before the compositor host window is destroyed. This gives the GPU
-// process a grace period to stop referencing it.
-const int kDestroyCompositorHostWindowDelay = 10000;
-
-// In mouse lock mode, we need to prevent the (invisible) cursor from hitting
-// the border of the view, in order to get valid movement information. However,
-// forcing the cursor back to the center of the view after each mouse move
-// doesn't work well. It reduces the frequency of useful WM_MOUSEMOVE messages
-// significantly. Therefore, we move the cursor to the center of the view only
-// if it approaches the border. |kMouseLockBorderPercentage| specifies the width
-// of the border area, in percentage of the corresponding dimension.
-const int kMouseLockBorderPercentage = 15;
-
-// A callback function for EnumThreadWindows to enumerate and dismiss
-// any owned popup windows.
-BOOL CALLBACK DismissOwnedPopups(HWND window, LPARAM arg) {
-  const HWND toplevel_hwnd = reinterpret_cast<HWND>(arg);
-
-  if (::IsWindowVisible(window)) {
-    const HWND owner = ::GetWindow(window, GW_OWNER);
-    if (toplevel_hwnd == owner) {
-      ::PostMessage(window, WM_CANCELMODE, 0, 0);
-    }
-  }
-
-  return TRUE;
-}
-
-void SendToGpuProcessHost(int gpu_host_id, scoped_ptr<IPC::Message> message) {
-  GpuProcessHost* gpu_process_host = GpuProcessHost::FromID(gpu_host_id);
-  if (!gpu_process_host)
-    return;
-
-  gpu_process_host->Send(message.release());
-}
-
-void PostTaskOnIOThread(const tracked_objects::Location& from_here,
-                        base::Closure task) {
-  BrowserThread::PostTask(BrowserThread::IO, from_here, task);
-}
-
-bool DecodeZoomGesture(HWND hwnd, const GESTUREINFO& gi,
-                       PageZoom* zoom, POINT* zoom_center) {
-  static long start = 0;
-  static POINT zoom_first;
-
-  if (gi.dwFlags == GF_BEGIN) {
-    start = gi.ullArguments;
-    zoom_first.x = gi.ptsLocation.x;
-    zoom_first.y = gi.ptsLocation.y;
-    ScreenToClient(hwnd, &zoom_first);
-    return false;
-  }
-
-  if (gi.dwFlags == GF_END)
-    return false;
-
-  POINT zoom_second = {0};
-  zoom_second.x = gi.ptsLocation.x;
-  zoom_second.y = gi.ptsLocation.y;
-  ScreenToClient(hwnd, &zoom_second);
-
-  if (zoom_first.x == zoom_second.x && zoom_first.y == zoom_second.y)
-    return false;
-
-  zoom_center->x = (zoom_first.x + zoom_second.x) / 2;
-  zoom_center->y = (zoom_first.y + zoom_second.y) / 2;
-
-  double zoom_factor =
-      static_cast<double>(gi.ullArguments)/static_cast<double>(start);
-
-  *zoom = zoom_factor >= 1 ? PAGE_ZOOM_IN : PAGE_ZOOM_OUT;
-
-  start = gi.ullArguments;
-  zoom_first = zoom_second;
-  return true;
-}
-
-bool DecodeScrollGesture(const GESTUREINFO& gi,
-                         POINT* start,
-                         POINT* delta){
-  // Windows gestures are streams of messages with begin/end messages that
-  // separate each new gesture. We key off the begin message to reset
-  // the static variables.
-  static POINT last_pt;
-  static POINT start_pt;
-
-  if (gi.dwFlags == GF_BEGIN) {
-    delta->x = 0;
-    delta->y = 0;
-    start_pt.x = gi.ptsLocation.x;
-    start_pt.y = gi.ptsLocation.y;
-  } else {
-    delta->x = gi.ptsLocation.x - last_pt.x;
-    delta->y = gi.ptsLocation.y - last_pt.y;
-  }
-  last_pt.x = gi.ptsLocation.x;
-  last_pt.y = gi.ptsLocation.y;
-  *start = start_pt;
-  return true;
-}
-
-blink::WebMouseWheelEvent MakeFakeScrollWheelEvent(HWND hwnd,
-                                                    POINT start,
-                                                    POINT delta) {
-  blink::WebMouseWheelEvent result;
-  result.type = WebInputEvent::MouseWheel;
-  result.timeStampSeconds = ::GetMessageTime() / 1000.0;
-  result.button = WebMouseEvent::ButtonNone;
-  result.globalX = start.x;
-  result.globalY = start.y;
-  // Map to window coordinates.
-  POINT client_point = { result.globalX, result.globalY };
-  MapWindowPoints(0, hwnd, &client_point, 1);
-  result.x = client_point.x;
-  result.y = client_point.y;
-  result.windowX = result.x;
-  result.windowY = result.y;
-  // Note that we support diagonal scrolling.
-  result.deltaX = static_cast<float>(delta.x);
-  result.wheelTicksX = WHEEL_DELTA;
-  result.deltaY = static_cast<float>(delta.y);
-  result.wheelTicksY = WHEEL_DELTA;
-  return result;
-}
-
-static const int kTouchMask = 0x7;
-
-inline int GetTouchType(const TOUCHINPUT& point) {
-  return point.dwFlags & kTouchMask;
-}
-
-inline void SetTouchType(TOUCHINPUT* point, int type) {
-  point->dwFlags = (point->dwFlags & kTouchMask) | type;
-}
-
-ui::EventType ConvertToUIEvent(blink::WebTouchPoint::State t) {
-  switch (t) {
-    case blink::WebTouchPoint::StatePressed:
-      return ui::ET_TOUCH_PRESSED;
-    case blink::WebTouchPoint::StateMoved:
-      return ui::ET_TOUCH_MOVED;
-    case blink::WebTouchPoint::StateStationary:
-      return ui::ET_TOUCH_STATIONARY;
-    case blink::WebTouchPoint::StateReleased:
-      return ui::ET_TOUCH_RELEASED;
-    case blink::WebTouchPoint::StateCancelled:
-      return ui::ET_TOUCH_CANCELLED;
-    default:
-      DCHECK(false) << "Unexpected ui type. " << t;
-      return ui::ET_UNKNOWN;
-  }
-}
-
-// Creates a WebGestureEvent corresponding to the given |gesture|
-blink::WebGestureEvent CreateWebGestureEvent(HWND hwnd,
-                                              const ui::GestureEvent& gesture) {
-  blink::WebGestureEvent gesture_event =
-      MakeWebGestureEventFromUIEvent(gesture);
-
-  POINT client_point = gesture.location().ToPOINT();
-  POINT screen_point = gesture.location().ToPOINT();
-  MapWindowPoints(hwnd, HWND_DESKTOP, &screen_point, 1);
-
-  gesture_event.x = client_point.x;
-  gesture_event.y = client_point.y;
-  gesture_event.globalX = screen_point.x;
-  gesture_event.globalY = screen_point.y;
-
-  return gesture_event;
-}
-
-blink::WebGestureEvent CreateFlingCancelEvent(double time_stamp) {
-  blink::WebGestureEvent gesture_event;
-  gesture_event.timeStampSeconds = time_stamp;
-  gesture_event.type = blink::WebGestureEvent::GestureFlingCancel;
-  gesture_event.sourceDevice = blink::WebGestureEvent::Touchscreen;
-  return gesture_event;
-}
-
-class TouchEventFromWebTouchPoint : public ui::TouchEvent {
- public:
-  TouchEventFromWebTouchPoint(const blink::WebTouchPoint& touch_point,
-                              base::TimeDelta& timestamp)
-      : ui::TouchEvent(ConvertToUIEvent(touch_point.state),
-                       touch_point.position,
-                       touch_point.id,
-                       timestamp) {
-    set_radius(touch_point.radiusX, touch_point.radiusY);
-    set_rotation_angle(touch_point.rotationAngle);
-    set_force(touch_point.force);
-    set_flags(ui::GetModifiersFromKeyState());
-  }
-
-  virtual ~TouchEventFromWebTouchPoint() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TouchEventFromWebTouchPoint);
-};
-
-bool ShouldSendPinchGesture() {
-  static bool pinch_allowed =
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePinch);
-  return pinch_allowed;
-}
-
-void GetScreenInfoForWindow(gfx::NativeViewId id,
-                            blink::WebScreenInfo* results) {
-  HWND window = gfx::NativeViewFromId(id);
-
-  HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTOPRIMARY);
-
-  MONITORINFOEX monitor_info;
-  monitor_info.cbSize = sizeof(MONITORINFOEX);
-  if (!base::win::GetMonitorInfoWrapper(monitor, &monitor_info))
-    return;
-
-  DEVMODE dev_mode;
-  dev_mode.dmSize = sizeof(dev_mode);
-  dev_mode.dmDriverExtra = 0;
-  EnumDisplaySettings(monitor_info.szDevice, ENUM_CURRENT_SETTINGS, &dev_mode);
-
-  blink::WebScreenInfo screen_info;
-  screen_info.depth = dev_mode.dmBitsPerPel;
-  screen_info.depthPerComponent = 8;
-  screen_info.deviceScaleFactor = gfx::win::GetDeviceScaleFactor();
-  screen_info.isMonochrome = dev_mode.dmColor == DMCOLOR_MONOCHROME;
-  screen_info.rect = gfx::Rect(monitor_info.rcMonitor);
-  screen_info.availableRect = gfx::Rect(monitor_info.rcWork);
-
-  *results = screen_info;
-}
-
-}  // namespace
-
-const wchar_t kRenderWidgetHostHWNDClass[] = L"Chrome_RenderWidgetHostHWND";
-
-// Wrapper for maintaining touchstate associated with a WebTouchEvent.
-class WebTouchState {
- public:
-  explicit WebTouchState(const RenderWidgetHostViewWin* window);
-
-  // Updates the current touchpoint state with the supplied touches.
-  // Touches will be consumed only if they are of the same type (e.g. down,
-  // up, move). Returns the number of consumed touches.
-  size_t UpdateTouchPoints(TOUCHINPUT* points, size_t count);
-
-  // Marks all active touchpoints as released.
-  bool ReleaseTouchPoints();
-
-  // The contained WebTouchEvent.
-  const blink::WebTouchEvent& touch_event() { return touch_event_; }
-
-  // Returns if any touches are modified in the event.
-  bool is_changed() { return touch_event_.changedTouchesLength != 0; }
-
- private:
-  // Adds a touch point or returns NULL if there's not enough space.
-  blink::WebTouchPoint* AddTouchPoint(TOUCHINPUT* touch_input);
-
-  // Copy details from a TOUCHINPUT to an existing WebTouchPoint, returning
-  // true if the resulting point is a stationary move.
-  bool UpdateTouchPoint(blink::WebTouchPoint* touch_point,
-                        TOUCHINPUT* touch_input);
-
-  // Find (or create) a mapping for _os_touch_id_.
-  unsigned int GetMappedTouch(unsigned int os_touch_id);
-
-  // Remove any mappings that are no longer in use.
-  void RemoveExpiredMappings();
-
-  blink::WebTouchEvent touch_event_;
-  const RenderWidgetHostViewWin* const window_;
-
-  ui::SequentialIDGenerator id_generator_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebTouchState);
-};
-
-typedef void (*MetroSetFrameWindow)(HWND window);
-typedef void (*MetroCloseFrameWindow)(HWND window);
-
-///////////////////////////////////////////////////////////////////////////////
-// RenderWidgetHostViewWin, public:
-
-RenderWidgetHostViewWin::RenderWidgetHostViewWin(RenderWidgetHost* widget)
-    : render_widget_host_(RenderWidgetHostImpl::From(widget)),
-      compositor_host_window_(NULL),
-      hide_compositor_window_at_next_paint_(false),
-      track_mouse_leave_(false),
-      imm32_manager_(new ui::IMM32Manager),
-      ime_notification_(false),
-      capture_enter_key_(false),
-      about_to_validate_and_paint_(false),
-      close_on_deactivate_(false),
-      being_destroyed_(false),
-      tooltip_hwnd_(NULL),
-      tooltip_showing_(false),
-      weak_factory_(this),
-      is_loading_(false),
-      text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
-      text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
-      can_compose_inline_(true),
-      is_fullscreen_(false),
-      ignore_mouse_movement_(true),
-      composition_range_(gfx::Range::InvalidRange()),
-      touch_state_(new WebTouchState(this)),
-      pointer_down_context_(false),
-      last_touch_location_(-1, -1),
-      touch_events_enabled_(ui::AreTouchEventsEnabled()),
-      gesture_recognizer_(ui::GestureRecognizer::Create()) {
-  render_widget_host_->SetView(this);
-  registrar_.Add(this,
-                 NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-                 NotificationService::AllBrowserContextsAndSources());
-  gesture_recognizer_->AddGestureEventHelper(this);
-}
-
-RenderWidgetHostViewWin::~RenderWidgetHostViewWin() {
-  gesture_recognizer_->RemoveGestureEventHelper(this);
-  UnlockMouse();
-  ResetTooltip();
-}
-
-void RenderWidgetHostViewWin::CreateWnd(HWND parent) {
-  // ATL function to create the window.
-  Create(parent);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// RenderWidgetHostViewWin, RenderWidgetHostView implementation:
-
-void RenderWidgetHostViewWin::InitAsChild(
-    gfx::NativeView parent_view) {
-  CreateWnd(parent_view);
-}
-
-void RenderWidgetHostViewWin::InitAsPopup(
-    RenderWidgetHostView* parent_host_view, const gfx::Rect& pos) {
-  close_on_deactivate_ = true;
-  DoPopupOrFullscreenInit(parent_host_view->GetNativeView(), pos,
-                          WS_EX_TOOLWINDOW);
-}
-
-void RenderWidgetHostViewWin::InitAsFullscreen(
-    RenderWidgetHostView* reference_host_view) {
-  gfx::Rect pos = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
-      reference_host_view->GetNativeView()).bounds();
-  is_fullscreen_ = true;
-  DoPopupOrFullscreenInit(gfx::GetWindowToParentTo(true), pos, 0);
-}
-
-RenderWidgetHost* RenderWidgetHostViewWin::GetRenderWidgetHost() const {
-  return render_widget_host_;
-}
-
-void RenderWidgetHostViewWin::WasShown() {
-  // |render_widget_host_| may be NULL if the WebContentsImpl is in the process
-  // of closing.
-  if (!render_widget_host_)
-    return;
-
-  if (!render_widget_host_->is_hidden())
-    return;
-
-  if (web_contents_switch_paint_time_.is_null())
-    web_contents_switch_paint_time_ = TimeTicks::Now();
-
-  render_widget_host_->WasShown();
-}
-
-void RenderWidgetHostViewWin::WasHidden() {
-  // |render_widget_host_| may be NULL if the WebContentsImpl is in the process
-  // of closing.
-  if (!render_widget_host_)
-    return;
-
-  if (render_widget_host_->is_hidden())
-    return;
-
-  ResetTooltip();
-
-  // Inform the renderer that we are being hidden so it can reduce its resource
-  // utilization.
-  render_widget_host_->WasHidden();
-
-  if (accelerated_surface_)
-    accelerated_surface_->WasHidden();
-
-  if (GetBrowserAccessibilityManager())
-    GetBrowserAccessibilityManager()->WasHidden();
-
-  web_contents_switch_paint_time_ = base::TimeTicks();
-}
-
-void RenderWidgetHostViewWin::SetSize(const gfx::Size& size) {
-  SetBounds(gfx::Rect(GetPixelBounds().origin(), size));
-}
-
-void RenderWidgetHostViewWin::SetBounds(const gfx::Rect& rect) {
-  if (being_destroyed_)
-    return;
-
-  // No SWP_NOREDRAW as autofill popups can move and the underneath window
-  // should redraw in that case.
-  UINT swp_flags = SWP_NOSENDCHANGING | SWP_NOOWNERZORDER | SWP_NOCOPYBITS |
-      SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE;
-
-  // If the style is not popup, you have to convert the point to client
-  // coordinate.
-  POINT point = { rect.x(), rect.y() };
-  if (GetStyle() & WS_CHILD)
-    ScreenToClient(&point);
-
-  SetWindowPos(NULL, point.x, point.y, rect.width(), rect.height(), swp_flags);
-  render_widget_host_->WasResized();
-}
-
-gfx::NativeView RenderWidgetHostViewWin::GetNativeView() const {
-  return m_hWnd;
-}
-
-gfx::NativeViewId RenderWidgetHostViewWin::GetNativeViewId() const {
-  return reinterpret_cast<gfx::NativeViewId>(m_hWnd);
-}
-
-gfx::NativeViewAccessible
-RenderWidgetHostViewWin::GetNativeViewAccessible() {
-  if (render_widget_host_ &&
-      !BrowserAccessibilityState::GetInstance()->IsAccessibleBrowser()) {
-    // Attempt to detect screen readers by sending an event with our custom id.
-    NotifyWinEvent(EVENT_SYSTEM_ALERT, m_hWnd, kIdCustom, CHILDID_SELF);
-  }
-
-  CreateBrowserAccessibilityManagerIfNeeded();
-
-  return GetBrowserAccessibilityManager()->GetRoot()->
-      ToBrowserAccessibilityWin();
-}
-
-void RenderWidgetHostViewWin::MovePluginWindows(
-    const gfx::Vector2d& scroll_offset,
-    const std::vector<WebPluginGeometry>& plugin_window_moves) {
-  MovePluginWindowsHelper(m_hWnd, plugin_window_moves);
-}
-
-static BOOL CALLBACK AddChildWindowToVector(HWND hwnd, LPARAM lparam) {
-  std::vector<HWND>* vector = reinterpret_cast<std::vector<HWND>*>(lparam);
-  vector->push_back(hwnd);
-  return TRUE;
-}
-
-void RenderWidgetHostViewWin::CleanupCompositorWindow() {
-  if (!compositor_host_window_)
-    return;
-
-  gfx::SetWindowUserData(compositor_host_window_, NULL);
-
-  // Hide the compositor and parent it to the desktop rather than destroying
-  // it immediately. The GPU process has a grace period to stop accessing the
-  // window. TODO(apatrick): the GPU process should acknowledge that it has
-  // finished with the window handle and the browser process should destroy it
-  // at that point.
-  ::ShowWindow(compositor_host_window_, SW_HIDE);
-  ::SetParent(compositor_host_window_, NULL);
-
-  BrowserThread::PostDelayedTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&::DestroyWindow),
-                 compositor_host_window_),
-      base::TimeDelta::FromMilliseconds(kDestroyCompositorHostWindowDelay));
-
-  compositor_host_window_ = NULL;
-}
-
-bool RenderWidgetHostViewWin::IsActivatable() const {
-  // Popups should not be activated.
-  return popup_type_ == blink::WebPopupTypeNone;
-}
-
-void RenderWidgetHostViewWin::Focus() {
-  if (IsWindow())
-    SetFocus();
-}
-
-void RenderWidgetHostViewWin::Blur() {
-  NOTREACHED();
-}
-
-bool RenderWidgetHostViewWin::HasFocus() const {
-  return ::GetFocus() == m_hWnd;
-}
-
-bool RenderWidgetHostViewWin::IsSurfaceAvailableForCopy() const {
-  if (render_widget_host_->is_accelerated_compositing_active())
-    return accelerated_surface_.get() && accelerated_surface_->IsReadyForCopy();
-  else
-    return !!render_widget_host_->GetBackingStore(false);
-}
-
-void RenderWidgetHostViewWin::Show() {
-  ShowWindow(SW_SHOW);
-  WasShown();
-}
-
-void RenderWidgetHostViewWin::Hide() {
-  if (!is_fullscreen_ && GetParent() == gfx::GetWindowToParentTo(true)) {
-    LOG(WARNING) << "Hide() called twice in a row: " << this << ":"
-        << GetParent();
-    return;
-  }
-
-  if (::GetFocus() == m_hWnd)
-    ::SetFocus(NULL);
-  ShowWindow(SW_HIDE);
-
-  WasHidden();
-}
-
-bool RenderWidgetHostViewWin::IsShowing() {
-  return !!IsWindowVisible();
-}
-
-gfx::Rect RenderWidgetHostViewWin::GetViewBounds() const {
-  return gfx::win::ScreenToDIPRect(GetPixelBounds());
-}
-
-gfx::Rect RenderWidgetHostViewWin::GetPixelBounds() const {
-  CRect window_rect;
-  GetWindowRect(&window_rect);
-  return gfx::Rect(window_rect);
-}
-
-void RenderWidgetHostViewWin::UpdateCursor(const WebCursor& cursor) {
-  current_cursor_ = cursor;
-  UpdateCursorIfOverSelf();
-}
-
-void RenderWidgetHostViewWin::UpdateCursorIfOverSelf() {
-  static HCURSOR kCursorArrow = LoadCursor(NULL, IDC_ARROW);
-  static HCURSOR kCursorAppStarting = LoadCursor(NULL, IDC_APPSTARTING);
-  static HINSTANCE module_handle = GetModuleHandle(
-      GetContentClient()->browser()->GetResourceDllName());
-
-  // If the mouse is over our HWND, then update the cursor state immediately.
-  CPoint pt;
-  GetCursorPos(&pt);
-  if (WindowFromPoint(pt) == m_hWnd) {
-    // We cannot pass in NULL as the module handle as this would only work for
-    // standard win32 cursors. We can also receive cursor types which are
-    // defined as webkit resources. We need to specify the module handle of
-    // chrome.dll while loading these cursors.
-    HCURSOR display_cursor = current_cursor_.GetCursor(module_handle);
-
-    // If a page is in the loading state, we want to show the Arrow+Hourglass
-    // cursor only when the current cursor is the ARROW cursor. In all other
-    // cases we should continue to display the current cursor.
-    if (is_loading_ && display_cursor == kCursorArrow)
-      display_cursor = kCursorAppStarting;
-
-    SetCursor(display_cursor);
-  }
-}
-
-void RenderWidgetHostViewWin::SetIsLoading(bool is_loading) {
-  is_loading_ = is_loading;
-  UpdateCursorIfOverSelf();
-}
-
-void RenderWidgetHostViewWin::TextInputTypeChanged(
-    ui::TextInputType type,
-    ui::TextInputMode input_mode,
-    bool can_compose_inline) {
-  if (text_input_type_ != type ||
-      text_input_mode_ != input_mode ||
-      can_compose_inline_ != can_compose_inline) {
-    const bool text_input_type_changed = (text_input_type_ != type) ||
-                                         (text_input_mode_ != input_mode);
-    text_input_type_ = type;
-    text_input_mode_ = input_mode;
-    can_compose_inline_ = can_compose_inline;
-    UpdateIMEState();
-    if (text_input_type_changed)
-      UpdateInputScopeIfNecessary(text_input_type_);
-  }
-}
-
-void RenderWidgetHostViewWin::SelectionBoundsChanged(
-    const ViewHostMsg_SelectionBounds_Params& params) {
-  bool is_enabled = (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE &&
-      text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD);
-  // Only update caret position if the input method is enabled.
-  if (is_enabled) {
-    caret_rect_ = gfx::UnionRects(params.anchor_rect, params.focus_rect);
-    imm32_manager_->UpdateCaretRect(m_hWnd, caret_rect_);
-  }
-}
-
-void RenderWidgetHostViewWin::ScrollOffsetChanged() {
-}
-
-void RenderWidgetHostViewWin::ImeCancelComposition() {
-  imm32_manager_->CancelIME(m_hWnd);
-}
-
-void RenderWidgetHostViewWin::ImeCompositionRangeChanged(
-    const gfx::Range& range,
-    const std::vector<gfx::Rect>& character_bounds) {
-  composition_range_ = range;
-  composition_character_bounds_ = character_bounds;
-}
-
-void RenderWidgetHostViewWin::Redraw() {
-  RECT damage_bounds;
-  GetUpdateRect(&damage_bounds, FALSE);
-
-  base::win::ScopedGDIObject<HRGN> damage_region(CreateRectRgn(0, 0, 0, 0));
-  GetUpdateRgn(damage_region, FALSE);
-
-  // Paint the invalid region synchronously.  Our caller will not paint again
-  // until we return, so by painting to the screen here, we ensure effective
-  // rate-limiting of backing store updates.  This helps a lot on pages that
-  // have animations or fairly expensive layout (e.g., google maps).
-  //
-  // We paint this window synchronously, however child windows (i.e. plugins)
-  // are painted asynchronously.  By avoiding synchronous cross-process window
-  // message dispatching we allow scrolling to be smooth, and also avoid the
-  // browser process locking up if the plugin process is hung.
-  //
-  RedrawWindow(NULL, damage_region, RDW_UPDATENOW | RDW_NOCHILDREN);
-
-  // Send the invalid rect in screen coordinates.
-  gfx::Rect invalid_screen_rect(damage_bounds);
-  invalid_screen_rect.Offset(GetPixelBounds().OffsetFromOrigin());
-
-  PaintPluginWindowsHelper(m_hWnd, invalid_screen_rect);
-}
-
-void RenderWidgetHostViewWin::DidUpdateBackingStore(
-    const gfx::Rect& scroll_rect,
-    const gfx::Vector2d& scroll_delta,
-    const std::vector<gfx::Rect>& copy_rects,
-    const std::vector<ui::LatencyInfo>& latency_info) {
-  TRACE_EVENT0("content", "RenderWidgetHostViewWin::DidUpdateBackingStore");
-  for (size_t i = 0; i < latency_info.size(); i++)
-    software_latency_info_.push_back(latency_info[i]);
-  if (render_widget_host_->is_hidden())
-    return;
-
-  // Schedule invalidations first so that the ScrollWindowEx call is closer to
-  // Redraw.  That minimizes chances of "flicker" resulting if the screen
-  // refreshes before we have a chance to paint the exposed area.  Somewhat
-  // surprisingly, this ordering matters.
-
-  for (size_t i = 0; i < copy_rects.size(); ++i) {
-    gfx::Rect pixel_rect = gfx::win::DIPToScreenRect(copy_rects[i]);
-    // Damage might not be DIP aligned.
-    pixel_rect.Inset(-1, -1);
-    RECT bounds = pixel_rect.ToRECT();
-    InvalidateRect(&bounds, false);
-  }
-
-  if (!scroll_rect.IsEmpty()) {
-    TRACE_EVENT0("content", "ScrollWindowEx");
-    gfx::Rect pixel_rect = gfx::win::DIPToScreenRect(scroll_rect);
-    // Damage might not be DIP aligned.
-    pixel_rect.Inset(-1, -1);
-    RECT clip_rect = pixel_rect.ToRECT();
-    float scale = gfx::win::GetDeviceScaleFactor();
-    int dx = static_cast<int>(scale * scroll_delta.x());
-    int dy = static_cast<int>(scale * scroll_delta.y());
-    ScrollWindowEx(dx, dy, NULL, &clip_rect, NULL, NULL, SW_INVALIDATE);
-  }
-
-  if (!about_to_validate_and_paint_)
-    Redraw();
-}
-
-void RenderWidgetHostViewWin::RenderProcessGone(base::TerminationStatus status,
-                                                int error_code) {
-  UpdateCursorIfOverSelf();
-  Destroy();
-}
-
-bool RenderWidgetHostViewWin::CanSubscribeFrame() const {
-  return render_widget_host_ != NULL;
-}
-
-void RenderWidgetHostViewWin::WillWmDestroy() {
-  CleanupCompositorWindow();
-  if (base::win::IsTSFAwareRequired())
-    ui::TSFBridge::GetInstance()->RemoveFocusedClient(this);
-}
-
-void RenderWidgetHostViewWin::Destroy() {
-  // We've been told to destroy.
-  // By clearing close_on_deactivate_, we prevent further deactivations
-  // (caused by windows messages resulting from the DestroyWindow) from
-  // triggering further destructions.  The deletion of this is handled by
-  // OnFinalMessage();
-  close_on_deactivate_ = false;
-  render_widget_host_ = NULL;
-  being_destroyed_ = true;
-  CleanupCompositorWindow();
-
-  // This releases the resources associated with input scope.
-  UpdateInputScopeIfNecessary(ui::TEXT_INPUT_TYPE_NONE);
-
-  if (is_fullscreen_ && win8::IsSingleWindowMetroMode()) {
-    MetroCloseFrameWindow close_frame_window =
-        reinterpret_cast<MetroCloseFrameWindow>(
-            ::GetProcAddress(base::win::GetMetroModule(), "CloseFrameWindow"));
-    DCHECK(close_frame_window);
-    close_frame_window(m_hWnd);
-  }
-
-  DestroyWindow();
-}
-
-void RenderWidgetHostViewWin::SetTooltipText(
-    const base::string16& tooltip_text) {
-  if (!render_widget_host_->is_hidden())
-    EnsureTooltip();
-
-  // Clamp the tooltip length to kMaxTooltipLength so that we don't
-  // accidentally DOS the user with a mega tooltip (since Windows doesn't seem
-  // to do this itself).
-  const base::string16 new_tooltip_text =
-      gfx::TruncateString(tooltip_text, kMaxTooltipLength);
-
-  if (new_tooltip_text != tooltip_text_) {
-    tooltip_text_ = new_tooltip_text;
-
-    // Need to check if the tooltip is already showing so that we don't
-    // immediately show the tooltip with no delay when we move the mouse from
-    // a region with no tooltip to a region with a tooltip.
-    if (::IsWindow(tooltip_hwnd_) && tooltip_showing_) {
-      ::SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
-      ::SendMessage(tooltip_hwnd_, TTM_POPUP, 0, 0);
-    }
-  } else {
-    // Make sure the tooltip gets closed after TTN_POP gets sent. For some
-    // reason this doesn't happen automatically, so moving the mouse around
-    // within the same link/image/etc doesn't cause the tooltip to re-appear.
-    if (!tooltip_showing_) {
-      if (::IsWindow(tooltip_hwnd_))
-        ::SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
-    }
-  }
-}
-
-BackingStore* RenderWidgetHostViewWin::AllocBackingStore(
-    const gfx::Size& size) {
-  return new BackingStoreWin(render_widget_host_, size);
-}
-
-void RenderWidgetHostViewWin::CopyFromCompositingSurface(
-    const gfx::Rect& src_subrect,
-    const gfx::Size& dst_size,
-    const base::Callback<void(bool, const SkBitmap&)>& callback) {
-  base::ScopedClosureRunner scoped_callback_runner(
-      base::Bind(callback, false, SkBitmap()));
-  if (!accelerated_surface_)
-    return;
-
-  if (dst_size.IsEmpty() || src_subrect.IsEmpty())
-    return;
-
-  ignore_result(scoped_callback_runner.Release());
-  accelerated_surface_->AsyncCopyTo(src_subrect, dst_size, callback);
-}
-
-void RenderWidgetHostViewWin::CopyFromCompositingSurfaceToVideoFrame(
-    const gfx::Rect& src_subrect,
-    const scoped_refptr<media::VideoFrame>& target,
-    const base::Callback<void(bool)>& callback) {
-  base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
-  if (!accelerated_surface_)
-    return;
-
-  if (!target || (target->format() != media::VideoFrame::YV12 &&
-                  target->format() != media::VideoFrame::I420))
-    return;
-
-  if (src_subrect.IsEmpty())
-    return;
-
-  ignore_result(scoped_callback_runner.Release());
-  accelerated_surface_->AsyncCopyToVideoFrame(src_subrect, target, callback);
-}
-
-bool RenderWidgetHostViewWin::CanCopyToVideoFrame() const {
-  return accelerated_surface_.get() && render_widget_host_ &&
-      render_widget_host_->is_accelerated_compositing_active();
-}
-
-void RenderWidgetHostViewWin::SetBackground(const SkBitmap& background) {
-  RenderWidgetHostViewBase::SetBackground(background);
-  render_widget_host_->SetBackground(background);
-}
-
-void RenderWidgetHostViewWin::ProcessAckedTouchEvent(
-    const TouchEventWithLatencyInfo& touch, InputEventAckState ack_result) {
-  DCHECK(touch_events_enabled_);
-
-  ScopedVector<ui::TouchEvent> events;
-  if (!MakeUITouchEventsFromWebTouchEvents(touch, &events, LOCAL_COORDINATES))
-    return;
-
-  ui::EventResult result = (ack_result ==
-      INPUT_EVENT_ACK_STATE_CONSUMED) ? ui::ER_HANDLED : ui::ER_UNHANDLED;
-  for (ScopedVector<ui::TouchEvent>::iterator iter = events.begin(),
-      end = events.end(); iter != end; ++iter)  {
-    scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
-    gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
-        *(*iter), result, this));
-    ProcessGestures(gestures.get());
-  }
-}
-
-void RenderWidgetHostViewWin::UpdateDesiredTouchMode() {
-  // Make sure that touch events even make sense.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-  if (touch_events_enabled_) {
-    CHECK(RegisterTouchWindow(m_hWnd, TWF_WANTPALM));
-  }
-}
-
-bool RenderWidgetHostViewWin::CanDispatchToConsumer(
-    ui::GestureConsumer* consumer) {
-  CHECK_EQ(static_cast<RenderWidgetHostViewWin*>(consumer), this);
-  return true;
-}
-
-void RenderWidgetHostViewWin::DispatchPostponedGestureEvent(
-    ui::GestureEvent* event) {
-  ForwardGestureEventToRenderer(event);
-}
-
-void RenderWidgetHostViewWin::DispatchCancelTouchEvent(
-    ui::TouchEvent* event) {
-  if (!render_widget_host_ || !touch_events_enabled_ ||
-      !render_widget_host_->ShouldForwardTouchEvent()) {
-    return;
-  }
-  DCHECK(event->type() == blink::WebInputEvent::TouchCancel);
-  blink::WebTouchEvent cancel_event;
-  cancel_event.type = blink::WebInputEvent::TouchCancel;
-  cancel_event.timeStampSeconds = event->time_stamp().InSecondsF();
-  render_widget_host_->ForwardTouchEventWithLatencyInfo(
-      cancel_event, *event->latency());
-}
-
-void RenderWidgetHostViewWin::SetHasHorizontalScrollbar(
-    bool has_horizontal_scrollbar) {
-}
-
-void RenderWidgetHostViewWin::SetScrollOffsetPinning(
-    bool is_pinned_to_left, bool is_pinned_to_right) {
-}
-
-void RenderWidgetHostViewWin::SetCompositionText(
-    const ui::CompositionText& composition) {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return;
-  }
-  if (!render_widget_host_)
-     return;
-  // ui::CompositionUnderline should be identical to
-  // blink::WebCompositionUnderline, so that we can do reinterpret_cast safely.
-  COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
-                 sizeof(blink::WebCompositionUnderline),
-                 ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
-  const std::vector<blink::WebCompositionUnderline>& underlines =
-      reinterpret_cast<const std::vector<blink::WebCompositionUnderline>&>(
-          composition.underlines);
-  render_widget_host_->ImeSetComposition(composition.text, underlines,
-                                         composition.selection.end(),
-                                         composition.selection.end());
-}
-
-void RenderWidgetHostViewWin::ConfirmCompositionText()  {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-}
-
-void RenderWidgetHostViewWin::ClearCompositionText() {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-}
-
-void RenderWidgetHostViewWin::InsertText(const base::string16& text) {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return;
-  }
-  if (render_widget_host_)
-    render_widget_host_->ImeConfirmComposition(text,
-                                               gfx::Range::InvalidRange(),
-                                               false);
-}
-
-void RenderWidgetHostViewWin::InsertChar(base::char16 ch, int flags) {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-}
-
-gfx::NativeWindow RenderWidgetHostViewWin::GetAttachedWindow() const {
-  return m_hWnd;
-}
-
-ui::TextInputType RenderWidgetHostViewWin::GetTextInputType() const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return ui::TEXT_INPUT_TYPE_NONE;
-  }
-  return text_input_type_;
-}
-
-ui::TextInputMode RenderWidgetHostViewWin::GetTextInputMode() const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return ui::TEXT_INPUT_MODE_DEFAULT;
-  }
-  return text_input_mode_;
-}
-
-bool RenderWidgetHostViewWin::CanComposeInline() const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-  return false;
-}
-
-gfx::Rect RenderWidgetHostViewWin::GetCaretBounds() const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return gfx::Rect(0, 0, 0, 0);
-  }
-  RECT tmp_rect = caret_rect_.ToRECT();
-  ClientToScreen(&tmp_rect);
-  return gfx::Rect(tmp_rect);
-}
-
-bool RenderWidgetHostViewWin::GetCompositionCharacterBounds(
-    uint32 index, gfx::Rect* rect) const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  DCHECK(rect);
-  if (index >= composition_character_bounds_.size())
-    return false;
-  RECT rec = composition_character_bounds_[index].ToRECT();
-  ClientToScreen(&rec);
-  *rect = gfx::Rect(rec);
-  return true;
-}
-
-bool RenderWidgetHostViewWin::HasCompositionText() const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-  return false;
-}
-
-bool RenderWidgetHostViewWin::GetTextRange(gfx::Range* range) const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  range->set_start(selection_text_offset_);
-  range->set_end(selection_text_offset_ + selection_text_.length());
-  return false;
-}
-
-bool RenderWidgetHostViewWin::GetCompositionTextRange(gfx::Range* range) const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-  return false;
-}
-
-bool RenderWidgetHostViewWin::GetSelectionRange(gfx::Range* range) const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  range->set_start(selection_range_.start());
-  range->set_end(selection_range_.end());
-  return false;
-}
-
-bool RenderWidgetHostViewWin::SetSelectionRange(const gfx::Range& range) {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-  return false;
-}
-
-bool RenderWidgetHostViewWin::DeleteRange(const gfx::Range& range) {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-  return false;
-}
-
-bool RenderWidgetHostViewWin::GetTextFromRange(const gfx::Range& range,
-                                               base::string16* text) const {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  gfx::Range selection_text_range(selection_text_offset_,
-      selection_text_offset_ + selection_text_.length());
-  if (!selection_text_range.Contains(range)) {
-    text->clear();
-    return false;
-  }
-  if (selection_text_range.EqualsIgnoringDirection(range)) {
-    *text = selection_text_;
-  } else {
-    *text = selection_text_.substr(
-        range.GetMin() - selection_text_offset_,
-        range.length());
-  }
-  return true;
-}
-
-void RenderWidgetHostViewWin::OnInputMethodChanged() {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-}
-
-bool RenderWidgetHostViewWin::ChangeTextDirectionAndLayoutAlignment(
-      base::i18n::TextDirection direction) {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return false;
-  }
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-  return false;
-}
-
-void RenderWidgetHostViewWin::ExtendSelectionAndDelete(
-    size_t before,
-    size_t after) {
-  if (!base::win::IsTSFAwareRequired()) {
-    NOTREACHED();
-    return;
-  }
-  if (!render_widget_host_)
-    return;
-  render_widget_host_->ExtendSelectionAndDelete(before, after);
-}
-
-void RenderWidgetHostViewWin::EnsureCaretInRect(const gfx::Rect& rect) {
-  // TODO(nona): Implement this function.
-  NOTIMPLEMENTED();
-}
-
-void RenderWidgetHostViewWin::OnCandidateWindowShown() {
-}
-
-void RenderWidgetHostViewWin::OnCandidateWindowUpdated() {
-}
-
-void RenderWidgetHostViewWin::OnCandidateWindowHidden() {
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// RenderWidgetHostViewWin, private:
-
-LRESULT RenderWidgetHostViewWin::OnCreate(CREATESTRUCT* create_struct) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnCreate");
-  // Call the WM_INPUTLANGCHANGE message handler to initialize the input locale
-  // of a browser process.
-  OnInputLangChange(0, 0);
-  // Marks that window as supporting mouse-wheel messages rerouting so it is
-  // scrolled when under the mouse pointer even if inactive.
-  props_.push_back(ui::SetWindowSupportsRerouteMouseWheel(m_hWnd));
-
-  WTSRegisterSessionNotification(m_hWnd, NOTIFY_FOR_THIS_SESSION);
-
-  UpdateDesiredTouchMode();
-  UpdateIMEState();
-
-  return 0;
-}
-
-void RenderWidgetHostViewWin::OnActivate(UINT action, BOOL minimized,
-                                         HWND window) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnActivate");
-  // If the container is a popup, clicking elsewhere on screen should close the
-  // popup.
-  if (close_on_deactivate_ && action == WA_INACTIVE) {
-    // Send a windows message so that any derived classes
-    // will get a change to override the default handling
-    SendMessage(WM_CANCELMODE);
-  }
-}
-
-void RenderWidgetHostViewWin::OnDestroy() {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnDestroy");
-  DetachPluginsHelper(m_hWnd);
-
-  props_.clear();
-
-  if (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
-      IsTouchWindow(m_hWnd, NULL)) {
-    UnregisterTouchWindow(m_hWnd);
-  }
-
-  CleanupCompositorWindow();
-
-  WTSUnRegisterSessionNotification(m_hWnd);
-
-  ResetTooltip();
-  TrackMouseLeave(false);
-}
-
-void RenderWidgetHostViewWin::OnPaint(HDC unused_dc) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnPaint");
-
-  // Grab the region to paint before creation of paint_dc since it clears the
-  // damage region.
-  base::win::ScopedGDIObject<HRGN> damage_region(CreateRectRgn(0, 0, 0, 0));
-  GetUpdateRgn(damage_region, FALSE);
-
-  CPaintDC paint_dc(m_hWnd);
-
-  if (!render_widget_host_)
-    return;
-
-  DCHECK(render_widget_host_->GetProcess()->HasConnection());
-
-  // If the GPU process is rendering to a child window, compositing is
-  // already triggered by damage to compositor_host_window_, so all we need to
-  // do here is clear borders during resize.
-  if (compositor_host_window_ &&
-      render_widget_host_->is_accelerated_compositing_active()) {
-    RECT host_rect, child_rect;
-    GetClientRect(&host_rect);
-    if (::GetClientRect(compositor_host_window_, &child_rect) &&
-        (child_rect.right < host_rect.right ||
-         child_rect.bottom < host_rect.bottom)) {
-      paint_dc.FillRect(&host_rect,
-          reinterpret_cast<HBRUSH>(GetStockObject(WHITE_BRUSH)));
-    }
-    return;
-  }
-
-  if (accelerated_surface_.get() &&
-      render_widget_host_->is_accelerated_compositing_active()) {
-    AcceleratedPaint(paint_dc.m_hDC);
-    return;
-  }
-
-  about_to_validate_and_paint_ = true;
-  BackingStoreWin* backing_store = static_cast<BackingStoreWin*>(
-      render_widget_host_->GetBackingStore(true));
-
-  // We initialize |paint_dc| (and thus call BeginPaint()) after calling
-  // GetBackingStore(), so that if it updates the invalid rect we'll catch the
-  // changes and repaint them.
-  about_to_validate_and_paint_ = false;
-
-  if (compositor_host_window_ && hide_compositor_window_at_next_paint_) {
-    ::ShowWindow(compositor_host_window_, SW_HIDE);
-    hide_compositor_window_at_next_paint_ = false;
-  }
-
-  gfx::Rect damaged_rect(paint_dc.m_ps.rcPaint);
-  if (damaged_rect.IsEmpty())
-    return;
-
-  if (backing_store) {
-    gfx::Rect bitmap_rect(gfx::Point(),
-                          gfx::win::DIPToScreenSize(backing_store->size()));
-
-    bool manage_colors = BackingStoreWin::ColorManagementEnabled();
-    if (manage_colors)
-      SetICMMode(paint_dc.m_hDC, ICM_ON);
-
-    // Blit only the damaged regions from the backing store.
-    DWORD data_size = GetRegionData(damage_region, 0, NULL);
-    scoped_ptr<char[]> region_data_buf;
-    RGNDATA* region_data = NULL;
-    RECT* region_rects = NULL;
-
-    if (data_size) {
-      region_data_buf.reset(new char[data_size]);
-      region_data = reinterpret_cast<RGNDATA*>(region_data_buf.get());
-      region_rects = reinterpret_cast<RECT*>(region_data->Buffer);
-      data_size = GetRegionData(damage_region, data_size, region_data);
-    }
-
-    if (!data_size) {
-      // Grabbing the damaged regions failed, fake with the whole rect.
-      data_size = sizeof(RGNDATAHEADER) + sizeof(RECT);
-      region_data_buf.reset(new char[data_size]);
-      region_data = reinterpret_cast<RGNDATA*>(region_data_buf.get());
-      region_rects = reinterpret_cast<RECT*>(region_data->Buffer);
-      region_data->rdh.nCount = 1;
-      region_rects[0] = damaged_rect.ToRECT();
-    }
-
-    for (DWORD i = 0; i < region_data->rdh.nCount; ++i) {
-      gfx::Rect paint_rect =
-          gfx::IntersectRects(bitmap_rect, gfx::Rect(region_rects[i]));
-      if (!paint_rect.IsEmpty()) {
-        BitBlt(paint_dc.m_hDC,
-               paint_rect.x(),
-               paint_rect.y(),
-               paint_rect.width(),
-               paint_rect.height(),
-               backing_store->hdc(),
-               paint_rect.x(),
-               paint_rect.y(),
-               SRCCOPY);
-      }
-    }
-
-    if (manage_colors)
-      SetICMMode(paint_dc.m_hDC, ICM_OFF);
-
-    // Fill the remaining portion of the damaged_rect with the background
-    if (damaged_rect.right() > bitmap_rect.right()) {
-      RECT r;
-      r.left = std::max(bitmap_rect.right(), damaged_rect.x());
-      r.right = damaged_rect.right();
-      r.top = damaged_rect.y();
-      r.bottom = std::min(bitmap_rect.bottom(), damaged_rect.bottom());
-      DrawBackground(r, &paint_dc);
-    }
-    if (damaged_rect.bottom() > bitmap_rect.bottom()) {
-      RECT r;
-      r.left = damaged_rect.x();
-      r.right = damaged_rect.right();
-      r.top = std::max(bitmap_rect.bottom(), damaged_rect.y());
-      r.bottom = damaged_rect.bottom();
-      DrawBackground(r, &paint_dc);
-    }
-    if (!whiteout_start_time_.is_null()) {
-      TimeDelta whiteout_duration = TimeTicks::Now() - whiteout_start_time_;
-      UMA_HISTOGRAM_TIMES("MPArch.RWHH_WhiteoutDuration", whiteout_duration);
-
-      // Reset the start time to 0 so that we start recording again the next
-      // time the backing store is NULL...
-      whiteout_start_time_ = TimeTicks();
-    }
-    if (!web_contents_switch_paint_time_.is_null()) {
-      TimeDelta web_contents_switch_paint_duration = TimeTicks::Now() -
-          web_contents_switch_paint_time_;
-      UMA_HISTOGRAM_TIMES("MPArch.RWH_TabSwitchPaintDuration",
-          web_contents_switch_paint_duration);
-      // Reset contents_switch_paint_time_ to 0 so future tab selections are
-      // recorded.
-      web_contents_switch_paint_time_ = TimeTicks();
-    }
-
-    for (size_t i = 0; i < software_latency_info_.size(); i++) {
-      software_latency_info_[i].AddLatencyNumber(
-          ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
-      render_widget_host_->FrameSwapped(software_latency_info_[i]);
-    }
-    software_latency_info_.clear();
-  } else {
-    DrawBackground(paint_dc.m_ps.rcPaint, &paint_dc);
-    if (whiteout_start_time_.is_null())
-      whiteout_start_time_ = TimeTicks::Now();
-  }
-}
-
-void RenderWidgetHostViewWin::DrawBackground(const RECT& dirty_rect,
-                                             CPaintDC* dc) {
-  if (!background_.empty()) {
-    gfx::Rect dirty_area(dirty_rect);
-    gfx::Canvas canvas(dirty_area.size(), 1.0f, true);
-    canvas.Translate(-dirty_area.OffsetFromOrigin());
-
-    gfx::Rect dc_rect(dc->m_ps.rcPaint);
-    // TODO(pkotwicz): Fix |background_| such that it is an ImageSkia.
-    canvas.TileImageInt(gfx::ImageSkia::CreateFrom1xBitmap(background_),
-                        0, 0, dc_rect.width(), dc_rect.height());
-
-    skia::DrawToNativeContext(canvas.sk_canvas(), *dc, dirty_area.x(),
-                              dirty_area.y(), NULL);
-  } else {
-    HBRUSH white_brush = reinterpret_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));
-    dc->FillRect(&dirty_rect, white_brush);
-  }
-}
-
-void RenderWidgetHostViewWin::OnNCPaint(HRGN update_region) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnNCPaint");
-  // Do nothing.  This suppresses the resize corner that Windows would
-  // otherwise draw for us.
-}
-
-void RenderWidgetHostViewWin::SetClickthroughRegion(SkRegion* region) {
-  transparent_region_.reset(region);
-}
-
-LRESULT RenderWidgetHostViewWin::OnNCHitTest(const CPoint& point) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnNCHitTest");
-  RECT rc;
-  GetWindowRect(&rc);
-  if (transparent_region_.get() &&
-      transparent_region_->contains(point.x - rc.left, point.y - rc.top)) {
-    SetMsgHandled(TRUE);
-    return HTTRANSPARENT;
-  }
-  SetMsgHandled(FALSE);
-  return 0;
-}
-
-LRESULT RenderWidgetHostViewWin::OnEraseBkgnd(HDC dc) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnEraseBkgnd");
-  return 1;
-}
-
-LRESULT RenderWidgetHostViewWin::OnSetCursor(HWND window, UINT hittest_code,
-                                             UINT mouse_message_id) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnSetCursor");
-  UpdateCursorIfOverSelf();
-  return 0;
-}
-
-void RenderWidgetHostViewWin::OnSetFocus(HWND window) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnSetFocus");
-  if (!render_widget_host_)
-    return;
-
-  if (GetBrowserAccessibilityManager())
-    GetBrowserAccessibilityManager()->GotFocus(pointer_down_context_);
-
-  render_widget_host_->GotFocus();
-  render_widget_host_->SetActive(true);
-
-  if (base::win::IsTSFAwareRequired())
-    ui::TSFBridge::GetInstance()->SetFocusedClient(m_hWnd, this);
-}
-
-void RenderWidgetHostViewWin::OnKillFocus(HWND window) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnKillFocus");
-  if (!render_widget_host_)
-    return;
-
-  render_widget_host_->SetActive(false);
-  render_widget_host_->Blur();
-
-  last_touch_location_ = gfx::Point(-1, -1);
-
-  if (base::win::IsTSFAwareRequired())
-    ui::TSFBridge::GetInstance()->RemoveFocusedClient(this);
-}
-
-void RenderWidgetHostViewWin::OnCaptureChanged(HWND window) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnCaptureChanged");
-  if (render_widget_host_)
-    render_widget_host_->LostCapture();
-  pointer_down_context_ = false;
-}
-
-void RenderWidgetHostViewWin::OnCancelMode() {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnCancelMode");
-  if (render_widget_host_)
-    render_widget_host_->LostCapture();
-
-  if ((is_fullscreen_ || close_on_deactivate_) &&
-      !weak_factory_.HasWeakPtrs()) {
-    // Dismiss popups and menus.  We do this asynchronously to avoid changing
-    // activation within this callstack, which may interfere with another window
-    // being activated.  We can synchronously hide the window, but we need to
-    // not change activation while doing so.
-    SetWindowPos(NULL, 0, 0, 0, 0,
-                 SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_NOMOVE |
-                 SWP_NOREPOSITION | SWP_NOSIZE | SWP_NOZORDER);
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&RenderWidgetHostViewWin::ShutdownHost,
-                   weak_factory_.GetWeakPtr()));
-  }
-}
-
-void RenderWidgetHostViewWin::OnInputLangChange(DWORD character_set,
-                                                HKL input_language_id) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnInputLangChange");
-  // Send the given Locale ID to the IMM32Manager object and retrieves whether
-  // or not the current input context has IMEs.
-  // If the current input context has IMEs, a browser process has to send a
-  // request to a renderer process that it needs status messages about
-  // the focused edit control from the renderer process.
-  // On the other hand, if the current input context does not have IMEs, the
-  // browser process also has to send a request to the renderer process that
-  // it does not need the status messages any longer.
-  // To minimize the number of this notification request, we should check if
-  // the browser process is actually retrieving the status messages (this
-  // state is stored in ime_notification_) and send a request only if the
-  // browser process has to update this status, its details are listed below:
-  // * If a browser process is not retrieving the status messages,
-  //   (i.e. ime_notification_ == false),
-  //   send this request only if the input context does have IMEs,
-  //   (i.e. ime_status == true);
-  //   When it successfully sends the request, toggle its notification status,
-  //   (i.e.ime_notification_ = !ime_notification_ = true).
-  // * If a browser process is retrieving the status messages
-  //   (i.e. ime_notification_ == true),
-  //   send this request only if the input context does not have IMEs,
-  //   (i.e. ime_status == false).
-  //   When it successfully sends the request, toggle its notification status,
-  //   (i.e.ime_notification_ = !ime_notification_ = false).
-  // To analyze the above actions, we can optimize them into the ones
-  // listed below:
-  // 1 Sending a request only if ime_status_ != ime_notification_, and;
-  // 2 Copying ime_status to ime_notification_ if it sends the request
-  //   successfully (because Action 1 shows ime_status = !ime_notification_.)
-  bool ime_status = imm32_manager_->SetInputLanguage();
-  if (ime_status != ime_notification_) {
-    if (render_widget_host_) {
-      render_widget_host_->SetInputMethodActive(ime_status);
-      ime_notification_ = ime_status;
-    }
-  }
-  // Call DefWindowProc() for consistency with other Chrome windows.
-  // TODO(hbono): This is a speculative fix for Bug 36354 and this code may be
-  // reverted if it does not fix it.
-  SetMsgHandled(FALSE);
-}
-
-void RenderWidgetHostViewWin::OnThemeChanged() {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnThemeChanged");
-  if (!render_widget_host_)
-    return;
-  render_widget_host_->Send(new ViewMsg_ThemeChanged(
-      render_widget_host_->GetRoutingID()));
-}
-
-LRESULT RenderWidgetHostViewWin::OnNotify(int w_param, NMHDR* header) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnNotify");
-  if (tooltip_hwnd_ == NULL)
-    return 0;
-
-  switch (header->code) {
-    case TTN_GETDISPINFO: {
-      NMTTDISPINFOW* tooltip_info = reinterpret_cast<NMTTDISPINFOW*>(header);
-      tooltip_info->szText[0] = L'\0';
-      tooltip_info->lpszText = const_cast<WCHAR*>(tooltip_text_.c_str());
-      ::SendMessage(
-        tooltip_hwnd_, TTM_SETMAXTIPWIDTH, 0, kTooltipMaxWidthPixels);
-      SetMsgHandled(TRUE);
-      break;
-    }
-    case TTN_POP:
-      tooltip_showing_ = false;
-      SetMsgHandled(TRUE);
-      break;
-    case TTN_SHOW:
-      // Tooltip shouldn't be shown when the mouse is locked.
-      DCHECK(!mouse_locked_);
-      tooltip_showing_ = true;
-      SetMsgHandled(TRUE);
-      break;
-  }
-  return 0;
-}
-
-LRESULT RenderWidgetHostViewWin::OnImeSetContext(
-    UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeSetContext");
-  if (!render_widget_host_)
-    return 0;
-
-  // We need status messages about the focused input control from a
-  // renderer process when:
-  //   * the current input context has IMEs, and;
-  //   * an application is activated.
-  // This seems to tell we should also check if the current input context has
-  // IMEs before sending a request, however, this WM_IME_SETCONTEXT is
-  // fortunately sent to an application only while the input context has IMEs.
-  // Therefore, we just start/stop status messages according to the activation
-  // status of this application without checks.
-  bool activated = (wparam == TRUE);
-  if (render_widget_host_) {
-    render_widget_host_->SetInputMethodActive(activated);
-    ime_notification_ = activated;
-  }
-
-  if (ime_notification_)
-    imm32_manager_->CreateImeWindow(m_hWnd);
-
-  imm32_manager_->CleanupComposition(m_hWnd);
-  return imm32_manager_->SetImeWindowStyle(
-      m_hWnd, message, wparam, lparam, &handled);
-}
-
-LRESULT RenderWidgetHostViewWin::OnImeStartComposition(
-    UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeStartComposition");
-  if (!render_widget_host_)
-    return 0;
-
-  // Reset the composition status and create IME windows.
-  imm32_manager_->CreateImeWindow(m_hWnd);
-  imm32_manager_->ResetComposition(m_hWnd);
-  // When the focus is on an element that does not draw composition by itself
-  // (i.e., PPAPI plugin not handling IME), let IME to draw the text. Otherwise
-  // we have to prevent WTL from calling ::DefWindowProc() because the function
-  // calls ::ImmSetCompositionWindow() and ::ImmSetCandidateWindow() to
-  // over-write the position of IME windows.
-  handled = (can_compose_inline_ ? TRUE : FALSE);
-  return 0;
-}
-
-LRESULT RenderWidgetHostViewWin::OnImeComposition(
-    UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeComposition");
-  if (!render_widget_host_)
-    return 0;
-
-  // At first, update the position of the IME window.
-  imm32_manager_->UpdateImeWindow(m_hWnd);
-
-  // ui::CompositionUnderline should be identical to
-  // blink::WebCompositionUnderline, so that we can do reinterpret_cast safely.
-  COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
-                 sizeof(blink::WebCompositionUnderline),
-                 ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
-
-  // Retrieve the result string and its attributes of the ongoing composition
-  // and send it to a renderer process.
-  ui::CompositionText composition;
-  if (imm32_manager_->GetResult(m_hWnd, lparam, &composition.text)) {
-    render_widget_host_->ImeConfirmComposition(
-        composition.text, gfx::Range::InvalidRange(), false);
-    imm32_manager_->ResetComposition(m_hWnd);
-    // Fall though and try reading the composition string.
-    // Japanese IMEs send a message containing both GCS_RESULTSTR and
-    // GCS_COMPSTR, which means an ongoing composition has been finished
-    // by the start of another composition.
-  }
-  // Retrieve the composition string and its attributes of the ongoing
-  // composition and send it to a renderer process.
-  if (imm32_manager_->GetComposition(m_hWnd, lparam, &composition)) {
-    // TODO(suzhe): due to a bug of webkit, we can't use selection range with
-    // composition string. See: https://bugs.webkit.org/show_bug.cgi?id=37788
-    composition.selection = gfx::Range(composition.selection.end());
-
-    // TODO(suzhe): convert both renderer_host and renderer to use
-    // ui::CompositionText.
-    const std::vector<blink::WebCompositionUnderline>& underlines =
-        reinterpret_cast<const std::vector<blink::WebCompositionUnderline>&>(
-            composition.underlines);
-    render_widget_host_->ImeSetComposition(
-        composition.text, underlines,
-        composition.selection.start(), composition.selection.end());
-  }
-  // We have to prevent WTL from calling ::DefWindowProc() because we do not
-  // want for the IMM (Input Method Manager) to send WM_IME_CHAR messages.
-  handled = TRUE;
-  if (!can_compose_inline_) {
-    // When the focus is on an element that does not draw composition by itself
-    // (i.e., PPAPI plugin not handling IME), let IME to draw the text, which
-    // is the default behavior of DefWindowProc. Note, however, even in this
-    // case we don't want GCS_RESULTSTR to be converted to WM_IME_CHAR messages.
-    // Thus we explicitly drop the flag.
-    return ::DefWindowProc(m_hWnd, message, wparam, lparam & ~GCS_RESULTSTR);
-  }
-  return 0;
-}
-
-LRESULT RenderWidgetHostViewWin::OnImeEndComposition(
-    UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeEndComposition");
-  if (!render_widget_host_)
-    return 0;
-
-  if (imm32_manager_->is_composing()) {
-    // A composition has been ended while there is an ongoing composition,
-    // i.e. the ongoing composition has been canceled.
-    // We need to reset the composition status both of the IMM32Manager object
-    // and of the renderer process.
-    render_widget_host_->ImeCancelComposition();
-    imm32_manager_->ResetComposition(m_hWnd);
-  }
-  imm32_manager_->DestroyImeWindow(m_hWnd);
-  // Let WTL call ::DefWindowProc() and release its resources.
-  handled = FALSE;
-  return 0;
-}
-
-LRESULT RenderWidgetHostViewWin::OnImeRequest(
-    UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeRequest");
-  if (!render_widget_host_) {
-    handled = FALSE;
-    return 0;
-  }
-
-  // Should not receive WM_IME_REQUEST message, if IME is disabled.
-  if (text_input_type_ == ui::TEXT_INPUT_TYPE_NONE ||
-      text_input_type_ == ui::TEXT_INPUT_TYPE_PASSWORD) {
-    handled = FALSE;
-    return 0;
-  }
-
-  switch (wparam) {
-    case IMR_RECONVERTSTRING:
-      return OnReconvertString(reinterpret_cast<RECONVERTSTRING*>(lparam));
-    case IMR_DOCUMENTFEED:
-      return OnDocumentFeed(reinterpret_cast<RECONVERTSTRING*>(lparam));
-    case IMR_QUERYCHARPOSITION:
-      return OnQueryCharPosition(reinterpret_cast<IMECHARPOSITION*>(lparam));
-    default:
-      handled = FALSE;
-      return 0;
-  }
-}
-
-LRESULT RenderWidgetHostViewWin::OnMouseEvent(UINT message, WPARAM wparam,
-                                              LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnMouseEvent");
-  handled = TRUE;
-
-  if (message == WM_MOUSELEAVE)
-    ignore_mouse_movement_ = true;
-
-  if (mouse_locked_) {
-    HandleLockedMouseEvent(message, wparam, lparam);
-    MoveCursorToCenterIfNecessary();
-    return 0;
-  }
-
-  if (::IsWindow(tooltip_hwnd_)) {
-    // Forward mouse events through to the tooltip window
-    MSG msg;
-    msg.hwnd = m_hWnd;
-    msg.message = message;
-    msg.wParam = wparam;
-    msg.lParam = lparam;
-    SendMessage(tooltip_hwnd_, TTM_RELAYEVENT, NULL,
-                reinterpret_cast<LPARAM>(&msg));
-  }
-
-  // Due to a bug in Windows, the simulated mouse events for a touch event
-  // outside our bounds are delivered to us if we were previously focused
-  // causing crbug.com/159982. As a workaround, we check if this event is a
-  // simulated mouse event outside our bounds, and if so, we send it to the
-  // right window.
-  if ((message == WM_LBUTTONDOWN || message == WM_LBUTTONUP) &&
-      ui::IsMouseEventFromTouch(message)) {
-    CPoint cursor_pos(GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
-    ClientToScreen(&cursor_pos);
-    if (!GetPixelBounds().Contains(cursor_pos.x, cursor_pos.y)) {
-      HWND window = WindowFromPoint(cursor_pos);
-      if (window) {
-        LRESULT nc_hit_result = SendMessage(window, WM_NCHITTEST, 0,
-            MAKELPARAM(cursor_pos.x, cursor_pos.y));
-        const bool in_client_area = (nc_hit_result == HTCLIENT);
-        int event_type;
-        if (message == WM_LBUTTONDOWN)
-          event_type = in_client_area ? WM_LBUTTONDOWN : WM_NCLBUTTONDOWN;
-        else
-          event_type = in_client_area ? WM_LBUTTONUP : WM_NCLBUTTONUP;
-
-        // Convert the coordinates to the target window.
-        RECT window_bounds;
-        ::GetWindowRect(window, &window_bounds);
-        int window_x = cursor_pos.x - window_bounds.left;
-        int window_y = cursor_pos.y - window_bounds.top;
-        if (in_client_area) {
-          ::PostMessage(window, event_type, wparam,
-              MAKELPARAM(window_x, window_y));
-        } else {
-          ::PostMessage(window, event_type, nc_hit_result,
-              MAKELPARAM(cursor_pos.x, cursor_pos.y));
-        }
-        return 0;
-      }
-    }
-  }
-
-  // TODO(jcampan): I am not sure if we should forward the message to the
-  // WebContentsImpl first in the case of popups.  If we do, we would need to
-  // convert the click from the popup window coordinates to the WebContentsImpl'
-  // window coordinates. For now we don't forward the message in that case to
-  // address bug #907474.
-  // Note: GetParent() on popup windows returns the top window and not the
-  // parent the window was created with (the parent and the owner of the popup
-  // is the first non-child view of the view that was specified to the create
-  // call).  So the WebContentsImpl's window would have to be specified to the
-  // RenderViewHostHWND as there is no way to retrieve it from the HWND.
-
-  // Don't forward if the container is a popup or fullscreen widget.
-  if (!is_fullscreen_ && !close_on_deactivate_) {
-    switch (message) {
-      case WM_LBUTTONDOWN:
-      case WM_MBUTTONDOWN:
-      case WM_RBUTTONDOWN:
-        // Finish the ongoing composition whenever a mouse click happens.
-        // It matches IE's behavior.
-        if (base::win::IsTSFAwareRequired()) {
-          ui::TSFBridge::GetInstance()->CancelComposition();
-        } else {
-          imm32_manager_->CleanupComposition(m_hWnd);
-        }
-        // Fall through.
-      case WM_MOUSEMOVE:
-      case WM_MOUSELEAVE: {
-        // Give the WebContentsImpl first crack at the message. It may want to
-        // prevent forwarding to the renderer if some higher level browser
-        // functionality is invoked.
-        LPARAM parent_msg_lparam = lparam;
-        if (message != WM_MOUSELEAVE) {
-          // For the messages except WM_MOUSELEAVE, before forwarding them to
-          // parent window, we should adjust cursor position from client
-          // coordinates in current window to client coordinates in its parent
-          // window.
-          CPoint cursor_pos(GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam));
-          ClientToScreen(&cursor_pos);
-          GetParent().ScreenToClient(&cursor_pos);
-          parent_msg_lparam = MAKELPARAM(cursor_pos.x, cursor_pos.y);
-        }
-        if (SendMessage(GetParent(), message, wparam, parent_msg_lparam) != 0) {
-          TRACE_EVENT0("browser", "EarlyOut_SentToParent");
-          return 1;
-        }
-      }
-    }
-  }
-
-  if (message == WM_LBUTTONDOWN && pointer_down_context_ &&
-      GetBrowserAccessibilityManager()) {
-    GetBrowserAccessibilityManager()->GotMouseDown();
-  }
-
-  if (message == WM_LBUTTONUP && ui::IsMouseEventFromTouch(message) &&
-      base::win::IsMetroProcess())
-    pointer_down_context_ = false;
-
-  ForwardMouseEventToRenderer(message, wparam, lparam);
-  return 0;
-}
-
-LRESULT RenderWidgetHostViewWin::OnKeyEvent(UINT message, WPARAM wparam,
-                                            LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnKeyEvent");
-  handled = TRUE;
-
-  // When Escape is pressed, force fullscreen windows to close if necessary.
-  if ((message == WM_KEYDOWN || message == WM_KEYUP) && wparam == VK_ESCAPE) {
-    if (is_fullscreen_) {
-      SendMessage(WM_CANCELMODE);
-      return 0;
-    }
-  }
-
-  // If we are a pop-up, forward tab related messages to our parent HWND, so
-  // that we are dismissed appropriately and so that the focus advance in our
-  // parent.
-  // TODO(jcampan): http://b/issue?id=1192881 Could be abstracted in the
-  //                FocusManager.
-  if (close_on_deactivate_ &&
-      (((message == WM_KEYDOWN || message == WM_KEYUP) && (wparam == VK_TAB)) ||
-        (message == WM_CHAR && wparam == L'\t'))) {
-    // First close the pop-up.
-    SendMessage(WM_CANCELMODE);
-    // Then move the focus by forwarding the tab key to the parent.
-    return ::SendMessage(GetParent(), message, wparam, lparam);
-  }
-
-  if (!render_widget_host_)
-    return 0;
-
-  // Bug 1845: we need to update the text direction when a user releases
-  // either a right-shift key or a right-control key after pressing both of
-  // them. So, we just update the text direction while a user is pressing the
-  // keys, and we notify the text direction when a user releases either of them.
-  // Bug 9718: http://crbug.com/9718 To investigate IE and notepad, this
-  // shortcut is enabled only on a PC having RTL keyboard layouts installed.
-  // We should emulate them.
-  if (ui::IMM32Manager::IsRTLKeyboardLayoutInstalled()) {
-    if (message == WM_KEYDOWN) {
-      if (wparam == VK_SHIFT) {
-        base::i18n::TextDirection dir;
-        if (ui::IMM32Manager::IsCtrlShiftPressed(&dir)) {
-          render_widget_host_->UpdateTextDirection(
-              dir == base::i18n::RIGHT_TO_LEFT ?
-              blink::WebTextDirectionRightToLeft :
-              blink::WebTextDirectionLeftToRight);
-        }
-      } else if (wparam != VK_CONTROL) {
-        // Bug 9762: http://crbug.com/9762 A user pressed a key except shift
-        // and control keys.
-        // When a user presses a key while he/she holds control and shift keys,
-        // we cancel sending an IPC message in NotifyTextDirection() below and
-        // ignore succeeding UpdateTextDirection() calls while we call
-        // NotifyTextDirection().
-        // To cancel it, this call set a flag that prevents sending an IPC
-        // message in NotifyTextDirection() only if we are going to send it.
-        // It is harmless to call this function if we aren't going to send it.
-        render_widget_host_->CancelUpdateTextDirection();
-      }
-    } else if (message == WM_KEYUP &&
-               (wparam == VK_SHIFT || wparam == VK_CONTROL)) {
-      // We send an IPC message only if we need to update the text direction.
-      render_widget_host_->NotifyTextDirection();
-    }
-  }
-
-  // Special processing for enter key: When user hits enter in omnibox
-  // we change focus to render host after the navigation, so repeat WM_KEYDOWNs
-  // and WM_KEYUP are going to render host, despite being initiated in other
-  // window. This code filters out these messages.
-  bool ignore_keyboard_event = false;
-  if (wparam == VK_RETURN) {
-    if (message == WM_KEYDOWN || message == WM_SYSKEYDOWN) {
-      if (KF_REPEAT & HIWORD(lparam)) {
-        // this is a repeated key
-        if (!capture_enter_key_)
-          ignore_keyboard_event = true;
-      } else {
-        capture_enter_key_ = true;
-      }
-    } else if (message == WM_KEYUP || message == WM_SYSKEYUP) {
-      if (!capture_enter_key_)
-        ignore_keyboard_event = true;
-      capture_enter_key_ = false;
-    } else {
-      // Ignore all other keyboard events for the enter key if not captured.
-      if (!capture_enter_key_)
-        ignore_keyboard_event = true;
-    }
-  }
-
-  if (render_widget_host_ && !ignore_keyboard_event) {
-    MSG msg = { m_hWnd, message, wparam, lparam };
-    render_widget_host_->ForwardKeyboardEvent(NativeWebKeyboardEvent(msg));
-  }
-
-  return 0;
-}
-
-LRESULT RenderWidgetHostViewWin::OnWheelEvent(UINT message, WPARAM wparam,
-                                              LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnWheelEvent");
-  // Forward the mouse-wheel message to the window under the mouse if it belongs
-  // to us.
-  if (message == WM_MOUSEWHEEL &&
-      ui::RerouteMouseWheel(m_hWnd, wparam, lparam)) {
-    handled = TRUE;
-    return 0;
-  }
-
-  // We get mouse wheel/scroll messages even if we are not in the foreground.
-  // So here we check if we have any owned popup windows in the foreground and
-  // dismiss them.
-  if (m_hWnd != GetForegroundWindow()) {
-    HWND toplevel_hwnd = ::GetAncestor(m_hWnd, GA_ROOT);
-    EnumThreadWindows(
-        GetCurrentThreadId(),
-        DismissOwnedPopups,
-        reinterpret_cast<LPARAM>(toplevel_hwnd));
-  }
-
-  if (render_widget_host_) {
-    blink::WebMouseWheelEvent wheel_event =
-        WebMouseWheelEventBuilder::Build(m_hWnd, message, wparam, lparam);
-    float scale = gfx::win::GetDeviceScaleFactor();
-    wheel_event.x /= scale;
-    wheel_event.y /= scale;
-    wheel_event.deltaX /= scale;
-    wheel_event.deltaY /= scale;
-
-    render_widget_host_->ForwardWheelEvent(wheel_event);
-  }
-  handled = TRUE;
-  return 0;
-}
-
-WebTouchState::WebTouchState(const RenderWidgetHostViewWin* window)
-    : window_(window),
-      id_generator_(0) {
-}
-
-size_t WebTouchState::UpdateTouchPoints(
-    TOUCHINPUT* points, size_t count) {
-  // First we reset all touch event state. This involves removing any released
-  // touchpoints and marking the rest as stationary. After that we go through
-  // and alter/add any touchpoints (from the touch input buffer) that we can
-  // coalesce into a single message. The return value is the number of consumed
-  // input message.
-  blink::WebTouchPoint* point = touch_event_.touches;
-  blink::WebTouchPoint* end = point + touch_event_.touchesLength;
-  while (point < end) {
-    if (point->state == blink::WebTouchPoint::StateReleased) {
-      *point = *(--end);
-      --touch_event_.touchesLength;
-    } else {
-      point->state = blink::WebTouchPoint::StateStationary;
-      point++;
-    }
-  }
-  touch_event_.changedTouchesLength = 0;
-  touch_event_.modifiers = content::EventFlagsToWebEventModifiers(
-      ui::GetModifiersFromKeyState());
-
-  // Consume all events of the same type and add them to the changed list.
-  int last_type = 0;
-  for (size_t i = 0; i < count; ++i) {
-    unsigned int mapped_id = GetMappedTouch(points[i].dwID);
-
-    blink::WebTouchPoint* point = NULL;
-    for (unsigned j = 0; j < touch_event_.touchesLength; ++j) {
-      if (static_cast<DWORD>(touch_event_.touches[j].id) == mapped_id) {
-        point =  &touch_event_.touches[j];
-        break;
-      }
-    }
-
-    // Use a move instead if we see a down on a point we already have.
-    int type = GetTouchType(points[i]);
-    if (point && type == TOUCHEVENTF_DOWN)
-      SetTouchType(&points[i], TOUCHEVENTF_MOVE);
-
-    // Stop processing when the event type changes.
-    if (touch_event_.changedTouchesLength && type != last_type)
-      return i;
-
-    touch_event_.timeStampSeconds = points[i].dwTime / 1000.0;
-
-    last_type = type;
-    switch (type) {
-      case TOUCHEVENTF_DOWN: {
-        if (!(point = AddTouchPoint(&points[i])))
-          continue;
-        touch_event_.type = blink::WebInputEvent::TouchStart;
-        break;
-      }
-
-      case TOUCHEVENTF_UP: {
-        if (!point)  // Just throw away a stray up.
-          continue;
-        point->state = blink::WebTouchPoint::StateReleased;
-        UpdateTouchPoint(point, &points[i]);
-        touch_event_.type = blink::WebInputEvent::TouchEnd;
-        break;
-      }
-
-      case TOUCHEVENTF_MOVE: {
-        if (point) {
-          point->state = blink::WebTouchPoint::StateMoved;
-          // Don't update the message if the point didn't really move.
-          if (UpdateTouchPoint(point, &points[i]))
-            continue;
-          touch_event_.type = blink::WebInputEvent::TouchMove;
-        } else if (touch_event_.changedTouchesLength) {
-          RemoveExpiredMappings();
-          // Can't add a point if we're already handling move events.
-          return i;
-        } else {
-          // Treat a move with no existing point as a down.
-          if (!(point = AddTouchPoint(&points[i])))
-            continue;
-          last_type = TOUCHEVENTF_DOWN;
-          SetTouchType(&points[i], TOUCHEVENTF_DOWN);
-          touch_event_.type = blink::WebInputEvent::TouchStart;
-        }
-        break;
-      }
-
-      default:
-        NOTREACHED();
-        continue;
-    }
-    touch_event_.changedTouches[touch_event_.changedTouchesLength++] = *point;
-  }
-
-  RemoveExpiredMappings();
-  return count;
-}
-
-void WebTouchState::RemoveExpiredMappings() {
-  blink::WebTouchPoint* point = touch_event_.touches;
-  blink::WebTouchPoint* end = point + touch_event_.touchesLength;
-  for (; point < end; ++point) {
-    if (point->state == blink::WebTouchPoint::StateReleased)
-      id_generator_.ReleaseGeneratedID(point->id);
-  }
-}
-
-
-bool WebTouchState::ReleaseTouchPoints() {
-  if (touch_event_.touchesLength == 0)
-    return false;
-  // Mark every active touchpoint as released.
-  touch_event_.type = blink::WebInputEvent::TouchEnd;
-  touch_event_.changedTouchesLength = touch_event_.touchesLength;
-  for (unsigned int i = 0; i < touch_event_.touchesLength; ++i) {
-    touch_event_.touches[i].state = blink::WebTouchPoint::StateReleased;
-    touch_event_.changedTouches[i].state =
-        blink::WebTouchPoint::StateReleased;
-  }
-
-  return true;
-}
-
-blink::WebTouchPoint* WebTouchState::AddTouchPoint(
-    TOUCHINPUT* touch_input) {
-  DCHECK(touch_event_.touchesLength <
-      blink::WebTouchEvent::touchesLengthCap);
-  if (touch_event_.touchesLength >=
-      blink::WebTouchEvent::touchesLengthCap)
-    return NULL;
-  blink::WebTouchPoint* point =
-      &touch_event_.touches[touch_event_.touchesLength++];
-  point->state = blink::WebTouchPoint::StatePressed;
-  point->id = GetMappedTouch(touch_input->dwID);
-  UpdateTouchPoint(point, touch_input);
-  return point;
-}
-
-bool WebTouchState::UpdateTouchPoint(
-    blink::WebTouchPoint* touch_point,
-    TOUCHINPUT* touch_input) {
-  CPoint coordinates(
-      TOUCH_COORD_TO_PIXEL(touch_input->x) /
-      gfx::win::GetUndocumentedDPITouchScale(),
-      TOUCH_COORD_TO_PIXEL(touch_input->y) /
-      gfx::win::GetUndocumentedDPITouchScale());
-  int radius_x = 1;
-  int radius_y = 1;
-  if (touch_input->dwMask & TOUCHINPUTMASKF_CONTACTAREA) {
-    // Some touch drivers send a contact area of "-1", yet flag it as valid.
-    radius_x = std::max(1,
-        static_cast<int>(TOUCH_COORD_TO_PIXEL(touch_input->cxContact) /
-                         gfx::win::GetUndocumentedDPITouchScale()));
-    radius_y = std::max(1,
-        static_cast<int>(TOUCH_COORD_TO_PIXEL(touch_input->cyContact) /
-                         gfx::win::GetUndocumentedDPITouchScale()));
-  }
-
-  // Detect and exclude stationary moves.
-  if (GetTouchType(*touch_input) == TOUCHEVENTF_MOVE &&
-      touch_point->screenPosition.x == coordinates.x &&
-      touch_point->screenPosition.y == coordinates.y &&
-      touch_point->radiusX == radius_x &&
-      touch_point->radiusY == radius_y) {
-    touch_point->state = blink::WebTouchPoint::StateStationary;
-    return true;
-  }
-
-  touch_point->screenPosition.x = coordinates.x;
-  touch_point->screenPosition.y = coordinates.y;
-  window_->ScreenToClient(&coordinates);
-  static float scale = gfx::win::GetDeviceScaleFactor();
-  touch_point->position.x = coordinates.x / scale;
-  touch_point->position.y = coordinates.y / scale;
-  touch_point->radiusX = radius_x;
-  touch_point->radiusY = radius_y;
-  touch_point->force = 0;
-  touch_point->rotationAngle = 0;
-  return false;
-}
-
-// Find (or create) a mapping for _os_touch_id_.
-unsigned int WebTouchState::GetMappedTouch(unsigned int os_touch_id) {
-  return id_generator_.GetGeneratedID(os_touch_id);
-}
-
-LRESULT RenderWidgetHostViewWin::OnTouchEvent(UINT message, WPARAM wparam,
-                                              LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnTouchEvent");
-  // Finish the ongoing composition whenever a touch event happens.
-  // It matches IE's behavior.
-  if (base::win::IsTSFAwareRequired()) {
-    ui::TSFBridge::GetInstance()->CancelComposition();
-  } else {
-    imm32_manager_->CleanupComposition(m_hWnd);
-  }
-
-  // TODO(jschuh): Add support for an arbitrary number of touchpoints.
-  size_t total = std::min(static_cast<int>(LOWORD(wparam)),
-      static_cast<int>(blink::WebTouchEvent::touchesLengthCap));
-  TOUCHINPUT points[blink::WebTouchEvent::touchesLengthCap];
-
-  if (!total || !ui::GetTouchInputInfoWrapper((HTOUCHINPUT)lparam, total,
-                                              points, sizeof(TOUCHINPUT))) {
-    TRACE_EVENT0("browser", "EarlyOut_NothingToDo");
-    return 0;
-  }
-
-  if (total == 1 && (points[0].dwFlags & TOUCHEVENTF_DOWN)) {
-    pointer_down_context_ = true;
-    last_touch_location_ = gfx::Point(
-        TOUCH_COORD_TO_PIXEL(points[0].x) /
-        gfx::win::GetUndocumentedDPITouchScale(),
-        TOUCH_COORD_TO_PIXEL(points[0].y) /
-        gfx::win::GetUndocumentedDPITouchScale());
-  }
-
-  bool should_forward = render_widget_host_->ShouldForwardTouchEvent() &&
-      touch_events_enabled_;
-
-  // Send a copy of the touch events on to the gesture recognizer.
-  for (size_t start = 0; start < total;) {
-    start += touch_state_->UpdateTouchPoints(points + start, total - start);
-    if (should_forward) {
-      if (touch_state_->is_changed())
-        render_widget_host_->ForwardTouchEventWithLatencyInfo(
-            touch_state_->touch_event(), ui::LatencyInfo());
-    } else {
-      const blink::WebTouchEvent& touch_event = touch_state_->touch_event();
-      base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(
-          touch_event.timeStampSeconds * 1000);
-      for (size_t i = 0; i < touch_event.touchesLength; ++i) {
-        scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
-        gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
-            TouchEventFromWebTouchPoint(touch_event.touches[i], timestamp),
-            ui::ER_UNHANDLED, this));
-        ProcessGestures(gestures.get());
-      }
-    }
-  }
-
-  CloseTouchInputHandle((HTOUCHINPUT)lparam);
-
-  return 0;
-}
-
-void RenderWidgetHostViewWin::ProcessGestures(
-    ui::GestureRecognizer::Gestures* gestures) {
-  if ((gestures == NULL) || gestures->empty())
-    return;
-  for (ui::GestureRecognizer::Gestures::iterator g_it = gestures->begin();
-      g_it != gestures->end();
-      ++g_it) {
-    ForwardGestureEventToRenderer(*g_it);
-  }
-}
-
-LRESULT RenderWidgetHostViewWin::OnMouseActivate(UINT message,
-                                                 WPARAM wparam,
-                                                 LPARAM lparam,
-                                                 BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnMouseActivate");
-  if (!render_widget_host_)
-    return MA_NOACTIVATE;
-
-  if (!IsActivatable())
-    return MA_NOACTIVATE;
-
-  HWND focus_window = GetFocus();
-  if (!::IsWindow(focus_window) || !IsChild(focus_window)) {
-    // We handle WM_MOUSEACTIVATE to set focus to the underlying plugin
-    // child window. This is to ensure that keyboard events are received
-    // by the plugin. The correct way to fix this would be send over
-    // an event to the renderer which would then eventually send over
-    // a setFocus call to the plugin widget. This would ensure that
-    // the renderer (webkit) knows about the plugin widget receiving
-    // focus.
-    // TODO(iyengar) Do the right thing as per the above comment.
-    POINT cursor_pos = {0};
-    ::GetCursorPos(&cursor_pos);
-    ::ScreenToClient(m_hWnd, &cursor_pos);
-    HWND child_window = ::RealChildWindowFromPoint(m_hWnd, cursor_pos);
-    if (::IsWindow(child_window) && child_window != m_hWnd) {
-      if (gfx::GetClassName(child_window) == kWrapperNativeWindowClassName)
-        child_window = ::GetWindow(child_window, GW_CHILD);
-
-      ::SetFocus(child_window);
-      return MA_NOACTIVATE;
-    }
-  }
-  handled = FALSE;
-  render_widget_host_->OnPointerEventActivate();
-  return MA_ACTIVATE;
-}
-
-LRESULT RenderWidgetHostViewWin::OnGestureEvent(
-      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnGestureEvent");
-
-  DCHECK(!touch_events_enabled_);
-  handled = FALSE;
-
-  GESTUREINFO gi = {sizeof(GESTUREINFO)};
-  HGESTUREINFO gi_handle = reinterpret_cast<HGESTUREINFO>(lparam);
-  if (!::GetGestureInfo(gi_handle, &gi)) {
-    DWORD error = GetLastError();
-    NOTREACHED() << "Unable to get gesture info. Error : " << error;
-    return 0;
-  }
-
-  if (gi.dwID == GID_ZOOM) {
-    PageZoom zoom = PAGE_ZOOM_RESET;
-    POINT zoom_center = {0};
-    if (DecodeZoomGesture(m_hWnd, gi, &zoom, &zoom_center)) {
-      handled = TRUE;
-      Send(new ViewMsg_ZoomFactor(render_widget_host_->GetRoutingID(),
-                                  zoom, zoom_center.x, zoom_center.y));
-    }
-  } else if (gi.dwID == GID_PAN) {
-    // Right now we only decode scroll gestures and we forward to the page
-    // as scroll events.
-    POINT start;
-    POINT delta;
-    if (DecodeScrollGesture(gi, &start, &delta)) {
-      handled = TRUE;
-      render_widget_host_->ForwardWheelEvent(
-          MakeFakeScrollWheelEvent(m_hWnd, start, delta));
-    }
-  }
-  ::CloseGestureInfoHandle(gi_handle);
-  return 0;
-}
-
-LRESULT RenderWidgetHostViewWin::OnMoveOrSize(
-    UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
-  // Reset the cliping rectangle if the mouse is locked.
-  if (mouse_locked_) {
-    CRect rect;
-    GetWindowRect(&rect);
-    ::ClipCursor(&rect);
-  }
-  return 0;
-}
-
-void RenderWidgetHostViewWin::CreateBrowserAccessibilityManagerIfNeeded() {
-  if (GetBrowserAccessibilityManager())
-    return;
-
-  HRESULT hr = ::CreateStdAccessibleObject(
-      m_hWnd, OBJID_WINDOW, IID_IAccessible,
-      reinterpret_cast<void **>(&window_iaccessible_));
-  DCHECK(SUCCEEDED(hr));
-
-  SetBrowserAccessibilityManager(
-      new BrowserAccessibilityManagerWin(
-          m_hWnd,
-          window_iaccessible_.get(),
-          BrowserAccessibilityManagerWin::GetEmptyDocument(),
-          this));
-}
-
-bool RenderWidgetHostViewWin::LockMouse() {
-  if (mouse_locked_)
-    return true;
-
-  mouse_locked_ = true;
-
-  // Hide the tooltip window if it is currently visible. When the mouse is
-  // locked, no mouse message is relayed to the tooltip window, so we don't need
-  // to worry that it will reappear.
-  if (::IsWindow(tooltip_hwnd_) && tooltip_showing_) {
-    ::SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
-    // Sending a TTM_POP message doesn't seem to actually hide the tooltip
-    // window, although we will receive a TTN_POP notification. As a result,
-    // ShowWindow() is explicitly called to hide the window.
-    ::ShowWindow(tooltip_hwnd_, SW_HIDE);
-  }
-
-  // TODO(yzshen): ShowCursor(FALSE) causes SetCursorPos() to be ignored on
-  // Remote Desktop.
-  ::ShowCursor(FALSE);
-
-  move_to_center_request_.pending = false;
-  last_mouse_position_.locked_global = last_mouse_position_.unlocked_global;
-
-  // Must set the clip rectangle before MoveCursorToCenterIfNecessary()
-  // so that if the cursor is moved it uses the clip rect set to the window
-  // rect. Otherwise, MoveCursorToCenterIfNecessary() may move the cursor
-  // to the center of the screen, and then we would clip to the window
-  // rect, thus moving the cursor and causing a movement delta.
-  CRect rect;
-  GetWindowRect(&rect);
-  ::ClipCursor(&rect);
-  MoveCursorToCenterIfNecessary();
-
-  return true;
-}
-
-void RenderWidgetHostViewWin::UnlockMouse() {
-  if (!mouse_locked_)
-    return;
-
-  mouse_locked_ = false;
-
-  ::ClipCursor(NULL);
-  ::SetCursorPos(last_mouse_position_.unlocked_global.x(),
-                 last_mouse_position_.unlocked_global.y());
-  ::ShowCursor(TRUE);
-
-  if (render_widget_host_)
-    render_widget_host_->LostMouseLock();
-}
-
-void RenderWidgetHostViewWin::Observe(
-    int type,
-    const NotificationSource& source,
-    const NotificationDetails& details) {
-  DCHECK(type == NOTIFICATION_RENDERER_PROCESS_TERMINATED);
-
-  // Get the RenderProcessHost that posted this notification, and exit
-  // if it's not the one associated with this host view.
-  RenderProcessHost* render_process_host =
-      Source<RenderProcessHost>(source).ptr();
-  DCHECK(render_process_host);
-  if (!render_widget_host_ ||
-      render_process_host != render_widget_host_->GetProcess()) {
-    return;
-  }
-
-  // If it was our RenderProcessHost that posted the notification,
-  // clear the BrowserAccessibilityManager, because the renderer is
-  // dead and any accessibility information we have is now stale.
-  SetBrowserAccessibilityManager(NULL);
-}
-
-static void PaintCompositorHostWindow(HWND hWnd) {
-  PAINTSTRUCT paint;
-  BeginPaint(hWnd, &paint);
-
-  RenderWidgetHostViewWin* win = static_cast<RenderWidgetHostViewWin*>(
-      gfx::GetWindowUserData(hWnd));
-  // Trigger composite to rerender window.
-  if (win)
-    win->AcceleratedPaint(paint.hdc);
-
-  EndPaint(hWnd, &paint);
-}
-
-// WndProc for the compositor host window. We use this instead of Default so
-// we can drop WM_PAINT and WM_ERASEBKGD messages on the floor.
-static LRESULT CALLBACK CompositorHostWindowProc(HWND hWnd, UINT message,
-                                                 WPARAM wParam, LPARAM lParam) {
-  switch (message) {
-  case WM_ERASEBKGND:
-    return 0;
-  case WM_PAINT:
-    PaintCompositorHostWindow(hWnd);
-    return 0;
-  default:
-    return DefWindowProc(hWnd, message, wParam, lParam);
-  }
-}
-
-void RenderWidgetHostViewWin::AcceleratedPaint(HDC dc) {
-  if (render_widget_host_)
-    render_widget_host_->ScheduleComposite();
-  if (accelerated_surface_)
-    accelerated_surface_->Present(dc);
-}
-
-void RenderWidgetHostViewWin::GetScreenInfo(blink::WebScreenInfo* results) {
-  GetScreenInfoForWindow(GetNativeViewId(), results);
-}
-
-gfx::Rect RenderWidgetHostViewWin::GetBoundsInRootWindow() {
-  RECT window_rect = {0};
-  HWND root_window = GetAncestor(m_hWnd, GA_ROOT);
-  ::GetWindowRect(root_window, &window_rect);
-  gfx::Rect rect(window_rect);
-
-  // Maximized windows are outdented from the work area by the frame thickness
-  // even though this "frame" is not painted.  This confuses code (and people)
-  // that think of a maximized window as corresponding exactly to the work area.
-  // Correct for this by subtracting the frame thickness back off.
-  if (::IsZoomed(root_window)) {
-    rect.Inset(GetSystemMetrics(SM_CXSIZEFRAME),
-               GetSystemMetrics(SM_CYSIZEFRAME));
-  }
-
-  return gfx::win::ScreenToDIPRect(rect);
-}
-
-// Creates a HWND within the RenderWidgetHostView that will serve as a host
-// for a HWND that the GPU process will create. The host window is used
-// to Z-position the GPU's window relative to other plugin windows.
-gfx::GLSurfaceHandle RenderWidgetHostViewWin::GetCompositingSurface() {
-  // If the window has been created, don't recreate it a second time
-  if (compositor_host_window_)
-    return gfx::GLSurfaceHandle(compositor_host_window_, gfx::NATIVE_TRANSPORT);
-
-  // On Vista and later we present directly to the view window rather than a
-  // child window.
-  if (GpuDataManagerImpl::GetInstance()->IsUsingAcceleratedSurface()) {
-    if (!accelerated_surface_)
-      accelerated_surface_.reset(new AcceleratedSurface(m_hWnd));
-    return gfx::GLSurfaceHandle(m_hWnd, gfx::NATIVE_TRANSPORT);
-  }
-
-  // On XP we need a child window that can be resized independently of the
-  // parent.
-  static ATOM atom = 0;
-  static HMODULE instance = NULL;
-  if (!atom) {
-    WNDCLASSEX window_class;
-    base::win::InitializeWindowClass(
-        L"CompositorHostWindowClass",
-        &base::win::WrappedWindowProc<CompositorHostWindowProc>,
-        0, 0, 0, NULL, NULL, NULL, NULL, NULL,
-        &window_class);
-    instance = window_class.hInstance;
-    atom = RegisterClassEx(&window_class);
-    DCHECK(atom);
-  }
-
-  RECT currentRect;
-  GetClientRect(&currentRect);
-
-  // Ensure window does not have zero area because D3D cannot create a zero
-  // area swap chain.
-  int width = std::max(1,
-      static_cast<int>(currentRect.right - currentRect.left));
-  int height = std::max(1,
-      static_cast<int>(currentRect.bottom - currentRect.top));
-
-  compositor_host_window_ = CreateWindowEx(
-      WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR,
-      MAKEINTATOM(atom), 0,
-      WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_DISABLED,
-      0, 0, width, height, m_hWnd, 0, instance, 0);
-  gfx::CheckWindowCreated(compositor_host_window_);
-
-  gfx::SetWindowUserData(compositor_host_window_, this);
-
-  gfx::GLSurfaceHandle surface_handle(compositor_host_window_,
-                                      gfx::NATIVE_TRANSPORT);
-  return surface_handle;
-}
-
-void RenderWidgetHostViewWin::ResizeCompositingSurface(const gfx::Size& size) {
-  // Ensure window does not have zero area because D3D cannot create a zero
-  // area swap chain.
-  ::SetWindowPos(compositor_host_window_,
-      NULL,
-      0, 0,
-      std::max(1, size.width()),
-      std::max(1, size.height()),
-      SWP_NOSENDCHANGING | SWP_NOCOPYBITS | SWP_NOZORDER |
-          SWP_NOACTIVATE | SWP_DEFERERASE | SWP_NOMOVE);
-}
-
-void RenderWidgetHostViewWin::OnAcceleratedCompositingStateChange() {
-  bool show = render_widget_host_->is_accelerated_compositing_active();
-  // When we first create the compositor, we will get a show request from
-  // the renderer before we have gotten the create request from the GPU. In this
-  // case, simply ignore the show request.
-  if (compositor_host_window_ == NULL)
-    return;
-
-  if (show) {
-    ::ShowWindow(compositor_host_window_, SW_SHOW);
-
-    // Get all the child windows of this view, including the compositor window.
-    std::vector<HWND> all_child_windows;
-    ::EnumChildWindows(m_hWnd, AddChildWindowToVector,
-        reinterpret_cast<LPARAM>(&all_child_windows));
-
-    // Build a list of just the plugin window handles
-    std::vector<HWND> plugin_windows;
-    bool compositor_host_window_found = false;
-    for (size_t i = 0; i < all_child_windows.size(); ++i) {
-      if (all_child_windows[i] != compositor_host_window_)
-        plugin_windows.push_back(all_child_windows[i]);
-      else
-        compositor_host_window_found = true;
-    }
-    DCHECK(compositor_host_window_found);
-
-    // Set all the plugin windows to be "after" the compositor window.
-    // When the compositor window is created, gets placed above plugins.
-    for (size_t i = 0; i < plugin_windows.size(); ++i) {
-      HWND next;
-      if (i + 1 < plugin_windows.size())
-        next = plugin_windows[i+1];
-      else
-        next = compositor_host_window_;
-      ::SetWindowPos(plugin_windows[i], next, 0, 0, 0, 0,
-          SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
-    }
-  } else {
-    // Drop the backing store for the accelerated surface when the accelerated
-    // compositor is disabled. Otherwise, a flash of the last presented frame
-    // could appear when it is next enabled.
-    if (accelerated_surface_)
-      accelerated_surface_->Suspend();
-    hide_compositor_window_at_next_paint_ = true;
-  }
-}
-
-void RenderWidgetHostViewWin::AcceleratedSurfaceInitialized(int host_id,
-                                                            int route_id) {
-}
-
-void RenderWidgetHostViewWin::AcceleratedSurfaceBuffersSwapped(
-    const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
-    int gpu_host_id) {
-  NOTREACHED();
-}
-
-void RenderWidgetHostViewWin::AcceleratedSurfacePostSubBuffer(
-    const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
-    int gpu_host_id) {
-  NOTREACHED();
-}
-
-void RenderWidgetHostViewWin::AcceleratedSurfaceSuspend() {
-    if (!accelerated_surface_)
-      return;
-
-    accelerated_surface_->Suspend();
-}
-
-void RenderWidgetHostViewWin::AcceleratedSurfaceRelease() {
-}
-
-bool RenderWidgetHostViewWin::HasAcceleratedSurface(
-      const gfx::Size& desired_size) {
-  // TODO(jbates) Implement this so this view can use GetBackingStore for both
-  // software and GPU frames. Defaulting to false just makes GetBackingStore
-  // only useable for software frames.
-  return false;
-}
-
-void RenderWidgetHostViewWin::SetAccessibilityFocus(int acc_obj_id) {
-  if (!render_widget_host_)
-    return;
-
-  render_widget_host_->AccessibilitySetFocus(acc_obj_id);
-}
-
-void RenderWidgetHostViewWin::AccessibilityDoDefaultAction(int acc_obj_id) {
-  if (!render_widget_host_)
-    return;
-
-  render_widget_host_->AccessibilityDoDefaultAction(acc_obj_id);
-}
-
-void RenderWidgetHostViewWin::AccessibilityScrollToMakeVisible(
-    int acc_obj_id, gfx::Rect subfocus) {
-  if (!render_widget_host_)
-    return;
-
-  render_widget_host_->AccessibilityScrollToMakeVisible(acc_obj_id, subfocus);
-}
-
-void RenderWidgetHostViewWin::AccessibilityScrollToPoint(
-    int acc_obj_id, gfx::Point point) {
-  if (!render_widget_host_)
-    return;
-
-  render_widget_host_->AccessibilityScrollToPoint(acc_obj_id, point);
-}
-
-void RenderWidgetHostViewWin::AccessibilitySetTextSelection(
-    int acc_obj_id, int start_offset, int end_offset) {
-  if (!render_widget_host_)
-    return;
-
-  render_widget_host_->AccessibilitySetTextSelection(
-      acc_obj_id, start_offset, end_offset);
-}
-
-gfx::Point RenderWidgetHostViewWin::GetLastTouchEventLocation() const {
-  return last_touch_location_;
-}
-
-void RenderWidgetHostViewWin::FatalAccessibilityTreeError() {
-  render_widget_host_->FatalAccessibilityTreeError();
-  SetBrowserAccessibilityManager(NULL);
-}
-
-LRESULT RenderWidgetHostViewWin::OnGetObject(UINT message, WPARAM wparam,
-                                             LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnGetObject");
-  if (kIdCustom == lparam) {
-    // An MSAA client requestes our custom id. Assume that we have detected an
-    // active windows screen reader.
-    BrowserAccessibilityState::GetInstance()->OnScreenReaderDetected();
-    render_widget_host_->SetAccessibilityMode(
-        BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode());
-
-    // Return with failure.
-    return static_cast<LRESULT>(0L);
-  }
-
-  if (lparam != OBJID_CLIENT) {
-    handled = false;
-    return static_cast<LRESULT>(0L);
-  }
-
-  IAccessible* iaccessible = GetNativeViewAccessible();
-  if (iaccessible)
-    return LresultFromObject(IID_IAccessible, wparam, iaccessible);
-
-  handled = false;
-  return static_cast<LRESULT>(0L);
-}
-
-LRESULT RenderWidgetHostViewWin::OnParentNotify(UINT message, WPARAM wparam,
-                                                LPARAM lparam, BOOL& handled) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnParentNotify");
-  handled = FALSE;
-
-  if (!render_widget_host_)
-    return 0;
-
-  switch (LOWORD(wparam)) {
-    case WM_LBUTTONDOWN:
-    case WM_RBUTTONDOWN:
-    case WM_MBUTTONDOWN:
-      render_widget_host_->StartUserGesture();
-      break;
-    default:
-      break;
-  }
-  return 0;
-}
-
-void RenderWidgetHostViewWin::OnFinalMessage(HWND window) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnFinalMessage");
-  // When the render widget host is being destroyed, it ends up calling
-  // Destroy() which NULLs render_widget_host_.
-  // Note: the following bug http://crbug.com/24248 seems to report that
-  // OnFinalMessage is called with a deleted |render_widget_host_|. It is not
-  // clear how this could happen, hence the NULLing of render_widget_host_
-  // above.
-  if (!render_widget_host_ && !being_destroyed_) {
-    // If you hit this NOTREACHED, please add a comment to report it on
-    // http://crbug.com/24248, including what you did when it happened and if
-    // you can repro.
-    NOTREACHED();
-  }
-  if (render_widget_host_)
-    render_widget_host_->ViewDestroyed();
-  if (base::win::IsTSFAwareRequired())
-    ui::TSFBridge::GetInstance()->RemoveFocusedClient(this);
-  delete this;
-}
-
-LRESULT RenderWidgetHostViewWin::OnSessionChange(UINT message,
-                                                 WPARAM wparam,
-                                                 LPARAM lparam,
-                                                 BOOL& handled) {
-  handled = FALSE;
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnSessionChange");
-
-  if (!accelerated_surface_)
-    return 0;
-
-  switch (wparam) {
-    case WTS_SESSION_LOCK:
-      accelerated_surface_->SetIsSessionLocked(true);
-      break;
-    case WTS_SESSION_UNLOCK:
-      // Force a repaint to update the window contents.
-      if (!render_widget_host_->is_hidden())
-        InvalidateRect(NULL, FALSE);
-      accelerated_surface_->SetIsSessionLocked(false);
-      break;
-    default:
-      break;
-  }
-
-  return 0;
-}
-
-void RenderWidgetHostViewWin::TrackMouseLeave(bool track) {
-  if (track == track_mouse_leave_)
-    return;
-  track_mouse_leave_ = track;
-
-  DCHECK(m_hWnd);
-
-  TRACKMOUSEEVENT tme;
-  tme.cbSize = sizeof(TRACKMOUSEEVENT);
-  tme.dwFlags = TME_LEAVE;
-  if (!track_mouse_leave_)
-    tme.dwFlags |= TME_CANCEL;
-  tme.hwndTrack = m_hWnd;
-
-  TrackMouseEvent(&tme);
-}
-
-bool RenderWidgetHostViewWin::Send(IPC::Message* message) {
-  if (!render_widget_host_)
-    return false;
-  return render_widget_host_->Send(message);
-}
-
-void RenderWidgetHostViewWin::EnsureTooltip() {
-  UINT message = TTM_NEWTOOLRECT;
-
-  TOOLINFO ti = {0};
-  ti.cbSize = sizeof(ti);
-  ti.hwnd = m_hWnd;
-  ti.uId = 0;
-  if (!::IsWindow(tooltip_hwnd_)) {
-    message = TTM_ADDTOOL;
-    tooltip_hwnd_ = CreateWindowEx(
-        WS_EX_TRANSPARENT | l10n_util::GetExtendedTooltipStyles(),
-        TOOLTIPS_CLASS, NULL, TTS_NOPREFIX, 0, 0, 0, 0, m_hWnd, NULL,
-        NULL, NULL);
-    if (!tooltip_hwnd_) {
-      // Tooltip creation can inexplicably fail. See bug 82913 for details.
-      LOG_GETLASTERROR(WARNING) <<
-          "Tooltip creation failed, tooltips won't work";
-      return;
-    }
-    ti.uFlags = TTF_TRANSPARENT;
-    ti.lpszText = LPSTR_TEXTCALLBACK;
-
-    // Ensure web content tooltips are displayed for at least this amount of
-    // time, to give users a chance to read longer messages.
-    const int kMinimumAutopopDurationMs = 10 * 1000;
-    int autopop_duration_ms =
-        SendMessage(tooltip_hwnd_, TTM_GETDELAYTIME, TTDT_AUTOPOP, NULL);
-    if (autopop_duration_ms < kMinimumAutopopDurationMs) {
-      SendMessage(tooltip_hwnd_, TTM_SETDELAYTIME, TTDT_AUTOPOP,
-                  kMinimumAutopopDurationMs);
-    }
-  }
-
-  CRect cr;
-  GetClientRect(&ti.rect);
-  SendMessage(tooltip_hwnd_, message, NULL, reinterpret_cast<LPARAM>(&ti));
-}
-
-void RenderWidgetHostViewWin::ResetTooltip() {
-  if (::IsWindow(tooltip_hwnd_))
-    ::DestroyWindow(tooltip_hwnd_);
-  tooltip_hwnd_ = NULL;
-}
-
-bool RenderWidgetHostViewWin::ForwardGestureEventToRenderer(
-    ui::GestureEvent* gesture) {
-  if (!render_widget_host_)
-    return false;
-
-  // Pinch gestures are disabled by default on windows desktop. See
-  // crbug.com/128477 and crbug.com/148816
-  if ((gesture->type() == ui::ET_GESTURE_PINCH_BEGIN ||
-      gesture->type() == ui::ET_GESTURE_PINCH_UPDATE ||
-      gesture->type() == ui::ET_GESTURE_PINCH_END) &&
-      !ShouldSendPinchGesture()) {
-    return true;
-  }
-
-  blink::WebGestureEvent web_gesture = CreateWebGestureEvent(m_hWnd, *gesture);
-  if (web_gesture.type == blink::WebGestureEvent::Undefined)
-    return false;
-  if (web_gesture.type == blink::WebGestureEvent::GestureTapDown) {
-    render_widget_host_->ForwardGestureEvent(
-        CreateFlingCancelEvent(gesture->time_stamp().InSecondsF()));
-  }
-  render_widget_host_->ForwardGestureEventWithLatencyInfo(web_gesture,
-                                                          *gesture->latency());
-  return true;
-}
-
-void RenderWidgetHostViewWin::ForwardMouseEventToRenderer(UINT message,
-                                                          WPARAM wparam,
-                                                          LPARAM lparam) {
-  TRACE_EVENT0("browser",
-               "RenderWidgetHostViewWin::ForwardMouseEventToRenderer");
-  if (!render_widget_host_) {
-    TRACE_EVENT0("browser", "EarlyOut_NoRWH");
-    return;
-  }
-
-  gfx::Point point = gfx::win::ScreenToDIPPoint(
-      gfx::Point(static_cast<short>(LOWORD(lparam)),
-                 static_cast<short>(HIWORD(lparam))));
-  lparam = MAKELPARAM(point.x(), point.y());
-
-  WebMouseEvent event(
-      WebMouseEventBuilder::Build(m_hWnd, message, wparam, lparam));
-
-  if (mouse_locked_) {
-    event.movementX = event.globalX - last_mouse_position_.locked_global.x();
-    event.movementY = event.globalY - last_mouse_position_.locked_global.y();
-    last_mouse_position_.locked_global.SetPoint(event.globalX, event.globalY);
-
-    event.x = last_mouse_position_.unlocked.x();
-    event.y = last_mouse_position_.unlocked.y();
-    event.windowX = last_mouse_position_.unlocked.x();
-    event.windowY = last_mouse_position_.unlocked.y();
-    event.globalX = last_mouse_position_.unlocked_global.x();
-    event.globalY = last_mouse_position_.unlocked_global.y();
-  } else {
-    if (ignore_mouse_movement_) {
-      ignore_mouse_movement_ = false;
-      event.movementX = 0;
-      event.movementY = 0;
-    } else {
-      event.movementX =
-          event.globalX - last_mouse_position_.unlocked_global.x();
-      event.movementY =
-          event.globalY - last_mouse_position_.unlocked_global.y();
-    }
-
-    last_mouse_position_.unlocked.SetPoint(event.windowX, event.windowY);
-    last_mouse_position_.unlocked_global.SetPoint(event.globalX, event.globalY);
-  }
-
-  // Windows sends (fake) mouse messages for touch events. Don't send these to
-  // the render widget.
-  if (!touch_events_enabled_ || !ui::IsMouseEventFromTouch(message)) {
-    // Send the event to the renderer before changing mouse capture, so that
-    // the capturelost event arrives after mouseup.
-    render_widget_host_->ForwardMouseEvent(event);
-
-    switch (event.type) {
-      case WebInputEvent::MouseMove:
-        TrackMouseLeave(true);
-        break;
-      case WebInputEvent::MouseLeave:
-        TrackMouseLeave(false);
-        break;
-      case WebInputEvent::MouseDown:
-        SetCapture();
-        break;
-      case WebInputEvent::MouseUp:
-        if (GetCapture() == m_hWnd)
-          ReleaseCapture();
-        break;
-    }
-  }
-
-  if (IsActivatable() && event.type == WebInputEvent::MouseDown) {
-    // This is a temporary workaround for bug 765011 to get focus when the
-    // mouse is clicked. This happens after the mouse down event is sent to
-    // the renderer because normally Windows does a WM_SETFOCUS after
-    // WM_LBUTTONDOWN.
-    SetFocus();
-  }
-}
-
-void RenderWidgetHostViewWin::ShutdownHost() {
-  weak_factory_.InvalidateWeakPtrs();
-  if (render_widget_host_)
-    render_widget_host_->Shutdown();
-  // Do not touch any members at this point, |this| has been deleted.
-}
-
-void RenderWidgetHostViewWin::DoPopupOrFullscreenInit(HWND parent_hwnd,
-                                                      const gfx::Rect& pos,
-                                                      DWORD ex_style) {
-  Create(parent_hwnd, NULL, NULL, WS_POPUP, ex_style);
-  gfx::Rect screen_rect = gfx::win::DIPToScreenRect(pos);
-  MoveWindow(screen_rect.x(), screen_rect.y(), screen_rect.width(),
-      screen_rect.height(), TRUE);
-  ShowWindow(IsActivatable() ? SW_SHOW : SW_SHOWNA);
-
-  if (is_fullscreen_ && win8::IsSingleWindowMetroMode()) {
-    MetroSetFrameWindow set_frame_window =
-        reinterpret_cast<MetroSetFrameWindow>(
-            ::GetProcAddress(base::win::GetMetroModule(), "SetFrameWindow"));
-    DCHECK(set_frame_window);
-    set_frame_window(m_hWnd);
-  }
-}
-
-CPoint RenderWidgetHostViewWin::GetClientCenter() const {
-  CRect rect;
-  GetClientRect(&rect);
-  return rect.CenterPoint();
-}
-
-void RenderWidgetHostViewWin::MoveCursorToCenterIfNecessary() {
-  DCHECK(mouse_locked_);
-
-  CRect rect;
-  GetClipCursor(&rect);
-  int border_x = rect.Width() * kMouseLockBorderPercentage / 100;
-  int border_y = rect.Height() * kMouseLockBorderPercentage / 100;
-
-  bool should_move =
-      last_mouse_position_.locked_global.x() < rect.left + border_x ||
-      last_mouse_position_.locked_global.x() > rect.right - border_x ||
-      last_mouse_position_.locked_global.y() < rect.top + border_y ||
-      last_mouse_position_.locked_global.y() > rect.bottom - border_y;
-
-  if (should_move) {
-    move_to_center_request_.pending = true;
-    move_to_center_request_.target = rect.CenterPoint();
-    if (!::SetCursorPos(move_to_center_request_.target.x(),
-                        move_to_center_request_.target.y())) {
-      LOG_GETLASTERROR(WARNING) << "Failed to set cursor position.";
-    }
-  }
-}
-
-void RenderWidgetHostViewWin::HandleLockedMouseEvent(UINT message,
-                                                     WPARAM wparam,
-                                                     LPARAM lparam) {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewWin::HandleLockedMouseEvent");
-  DCHECK(mouse_locked_);
-
-  if (message == WM_MOUSEMOVE && move_to_center_request_.pending) {
-    // Ignore WM_MOUSEMOVE messages generated by
-    // MoveCursorToCenterIfNecessary().
-    CPoint current_position(LOWORD(lparam), HIWORD(lparam));
-    ClientToScreen(&current_position);
-    if (move_to_center_request_.target.x() == current_position.x &&
-        move_to_center_request_.target.y() == current_position.y) {
-      move_to_center_request_.pending = false;
-      last_mouse_position_.locked_global = move_to_center_request_.target;
-      return;
-    }
-  }
-
-  ForwardMouseEventToRenderer(message, wparam, lparam);
-}
-
-LRESULT RenderWidgetHostViewWin::OnDocumentFeed(RECONVERTSTRING* reconv) {
-  size_t target_offset;
-  size_t target_length;
-  bool has_composition;
-  if (!composition_range_.is_empty()) {
-    target_offset = composition_range_.GetMin();
-    target_length = composition_range_.length();
-    has_composition = true;
-  } else if (selection_range_.IsValid()) {
-    target_offset = selection_range_.GetMin();
-    target_length = selection_range_.length();
-    has_composition = false;
-  } else {
-    return 0;
-  }
-
-  size_t len = selection_text_.length();
-  size_t need_size = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
-
-  if (target_offset < selection_text_offset_ ||
-      target_offset + target_length > selection_text_offset_ + len) {
-    return 0;
-  }
-
-  if (!reconv)
-    return need_size;
-
-  if (reconv->dwSize < need_size)
-    return 0;
-
-  reconv->dwVersion = 0;
-  reconv->dwStrLen = len;
-  reconv->dwStrOffset = sizeof(RECONVERTSTRING);
-  reconv->dwCompStrLen = has_composition ? target_length: 0;
-  reconv->dwCompStrOffset =
-      (target_offset - selection_text_offset_) * sizeof(WCHAR);
-  reconv->dwTargetStrLen = target_length;
-  reconv->dwTargetStrOffset = reconv->dwCompStrOffset;
-  memcpy(reinterpret_cast<char*>(reconv) + sizeof(RECONVERTSTRING),
-         selection_text_.c_str(), len * sizeof(WCHAR));
-
-  // According to Microsft API document, IMR_RECONVERTSTRING and
-  // IMR_DOCUMENTFEED should return reconv, but some applications return
-  // need_size.
-  return reinterpret_cast<LRESULT>(reconv);
-}
-
-LRESULT RenderWidgetHostViewWin::OnReconvertString(RECONVERTSTRING* reconv) {
-  // If there is a composition string already, we don't allow reconversion.
-  if (imm32_manager_->is_composing())
-    return 0;
-
-  if (selection_range_.is_empty())
-    return 0;
-
-  if (selection_text_.empty())
-    return 0;
-
-  if (selection_range_.GetMin() < selection_text_offset_ ||
-      selection_range_.GetMax() >
-      selection_text_offset_ + selection_text_.length()) {
-    return 0;
-  }
-
-  size_t len = selection_range_.length();
-  size_t need_size = sizeof(RECONVERTSTRING) + len * sizeof(WCHAR);
-
-  if (!reconv)
-    return need_size;
-
-  if (reconv->dwSize < need_size)
-    return 0;
-
-  reconv->dwVersion = 0;
-  reconv->dwStrLen = len;
-  reconv->dwStrOffset = sizeof(RECONVERTSTRING);
-  reconv->dwCompStrLen = len;
-  reconv->dwCompStrOffset = 0;
-  reconv->dwTargetStrLen = len;
-  reconv->dwTargetStrOffset = 0;
-
-  size_t offset = selection_range_.GetMin() - selection_text_offset_;
-  memcpy(reinterpret_cast<char*>(reconv) + sizeof(RECONVERTSTRING),
-         selection_text_.c_str() + offset, len * sizeof(WCHAR));
-
-  // According to Microsft API document, IMR_RECONVERTSTRING and
-  // IMR_DOCUMENTFEED should return reconv, but some applications return
-  // need_size.
-  return reinterpret_cast<LRESULT>(reconv);
-}
-
-LRESULT RenderWidgetHostViewWin::OnQueryCharPosition(
-    IMECHARPOSITION* position) {
-  DCHECK(position);
-
-  if (position->dwSize < sizeof(IMECHARPOSITION))
-    return 0;
-
-  RECT target_rect = {};
-  if (imm32_manager_->is_composing() && !composition_range_.is_empty() &&
-      position->dwCharPos < composition_character_bounds_.size()) {
-    target_rect =
-        composition_character_bounds_[position->dwCharPos].ToRECT();
-  } else if (position->dwCharPos == 0) {
-    // When there is no on-going composition but |position->dwCharPos| is 0,
-    // use the caret rect. This behavior is the same to RichEdit. In fact,
-    // CUAS (Cicero Unaware Application Support) relies on this behavior to
-    // implement ITfContextView::GetTextExt on top of IMM32-based applications.
-    target_rect = caret_rect_.ToRECT();
-  } else {
-    return 0;
-  }
-  ClientToScreen(&target_rect);
-
-  RECT document_rect = GetPixelBounds().ToRECT();
-  ClientToScreen(&document_rect);
-
-  position->pt.x = target_rect.left;
-  position->pt.y = target_rect.top;
-  position->cLineHeight = target_rect.bottom - target_rect.top;
-  position->rcDocument = document_rect;
-  return 1;
-}
-
-void RenderWidgetHostViewWin::UpdateIMEState() {
-  if (base::win::IsTSFAwareRequired()) {
-    ui::TSFBridge::GetInstance()->OnTextInputTypeChanged(this);
-    return;
-  }
-  if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE &&
-      text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD) {
-    imm32_manager_->EnableIME(m_hWnd);
-    imm32_manager_->SetUseCompositionWindow(!can_compose_inline_);
-  } else {
-    imm32_manager_->DisableIME(m_hWnd);
-  }
-
-  imm32_manager_->SetTextInputMode(m_hWnd, text_input_mode_);
-}
-
-void RenderWidgetHostViewWin::UpdateInputScopeIfNecessary(
-    ui::TextInputType text_input_type) {
-  // The text store is responsible for handling input scope when TSF-aware is
-  // required.
-  if (base::win::IsTSFAwareRequired())
-    return;
-
-  ui::tsf_inputscope::SetInputScopeForTsfUnawareWindow(
-      m_hWnd, text_input_type, text_input_mode_);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// RenderWidgetHostView, public:
-
-// static
-RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
-    RenderWidgetHost* widget) {
-  return new RenderWidgetHostViewWin(widget);
-}
-
-// static
-void RenderWidgetHostViewPort::GetDefaultScreenInfo(
-      blink::WebScreenInfo* results) {
-  GetScreenInfoForWindow(0, results);
-}
-
-}  // namespace content