Fix issue where window bounds were being passed with wrong coordinates.

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 659 matching lines @@
     old_child->popup_parent_host_view_ = NULL;
   }
   popup_parent_host_view_->popup_child_host_view_ = this;
   window_->SetType(aura::client::WINDOW_TYPE_MENU);
   window_->Init(ui::LAYER_TEXTURED);
   window_->SetName("RenderWidgetHostViewAura");
 
   aura::RootWindow* root = popup_parent_host_view_->window_->GetRootWindow();
   window_->SetDefaultParentByRootWindow(root, bounds_in_screen);
 
-  // TODO(erg): While I could make sure details of the StackingClient are
-  // hidden behind aura, hiding the details of the ScreenPositionClient will
-  // take another effort.
-  aura::client::ScreenPositionClient* screen_position_client =
-      aura::client::GetScreenPositionClient(root);
-  gfx::Point origin_in_parent(bounds_in_screen.origin());
-  if (screen_position_client) {
-    screen_position_client->ConvertPointFromScreen(
-        window_->parent(), &origin_in_parent);
-  }
-  SetBounds(gfx::Rect(origin_in_parent, bounds_in_screen.size()));
+  SetBounds(bounds_in_screen);
   Show();
 }
 
 void RenderWidgetHostViewAura::InitAsFullscreen(
     RenderWidgetHostView* reference_host_view) {
   is_fullscreen_ = true;
   window_->SetType(aura::client::WINDOW_TYPE_NORMAL);
   window_->Init(ui::LAYER_TEXTURED);
   window_->SetName("RenderWidgetHostViewAura");
   window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
 
   aura::RootWindow* parent = NULL;
   gfx::Rect bounds;
   if (reference_host_view) {
     aura::Window* reference_window =
         static_cast<RenderWidgetHostViewAura*>(reference_host_view)->window_;
     if (reference_window) {
       host_tracker_.reset(new aura::WindowTracker);
       host_tracker_->Add(reference_window);
     }
     gfx::Display display = gfx::Screen::GetScreenFor(window_)->
         GetDisplayNearestWindow(reference_window);
     parent = reference_window->GetRootWindow();
     bounds = display.bounds();
   }
+
   window_->SetDefaultParentByRootWindow(parent, bounds);
   Show();
   Focus();
 }
 
 RenderWidgetHost* RenderWidgetHostViewAura::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAura::WasShown() {
@@ skipping 30 matching lines @@
   if (root_window) {
     HWND parent = root_window->GetAcceleratedWidget();
     LPARAM lparam = reinterpret_cast<LPARAM>(this);
 
     EnumChildWindows(parent, HideWindowsCallback, lparam);
   }
 #endif
 }
 
 void RenderWidgetHostViewAura::SetSize(const gfx::Size& size) {
-  SetBounds(gfx::Rect(window_->bounds().origin(), size));
+  // For a set size operation, we don't care what coordinate system the origin
+  // of the window is stored in, it's only important to make sure the origin
+  // remains constant after the operation.
+  InternalSetBounds(gfx::Rect(window_->bounds().origin(), size));
 }
 
 void RenderWidgetHostViewAura::SetBounds(const gfx::Rect& rect) {
+  // RenderWidgetHostViewAura::SetBounds() takes screen coordinates, but
+  // Window::SetBounds() takes parent coordinates, so we do the conversion here.
+  aura::RootWindow* root = window_->GetRootWindow();
+  aura::client::ScreenPositionClient* screen_position_client =
+      aura::client::GetScreenPositionClient(root);
+  gfx::Point origin_in_parent(rect.origin());
+  if (screen_position_client) {
+    screen_position_client->ConvertPointFromScreen(
+        window_->parent(), &origin_in_parent);
+  }
+
+  InternalSetBounds(gfx::Rect(origin_in_parent, rect.size()));
+}
+
+gfx::NativeView RenderWidgetHostViewAura::GetNativeView() const {
+  return window_;
+}
+
+gfx::NativeViewId RenderWidgetHostViewAura::GetNativeViewId() const {
+#if defined(OS_WIN)
+  aura::RootWindow* root_window = window_->GetRootWindow();
+  if (root_window) {
+    HWND window = root_window->GetAcceleratedWidget();
+    return reinterpret_cast<gfx::NativeViewId>(window);
+  }
+#endif
+  return static_cast<gfx::NativeViewId>(NULL);
+}
+
+gfx::NativeViewAccessible RenderWidgetHostViewAura::GetNativeViewAccessible() {
+#if defined(OS_WIN)
+  aura::RootWindow* root_window = window_->GetRootWindow();
+  if (!root_window)
+    return static_cast<gfx::NativeViewAccessible>(NULL);
+  HWND hwnd = root_window->GetAcceleratedWidget();
+
+  BrowserAccessibilityManager* manager =
+      GetOrCreateBrowserAccessibilityManager();
+  if (manager)
+    return manager->GetRoot()->ToBrowserAccessibilityWin();
+#endif
+
+  NOTIMPLEMENTED();
+  return static_cast<gfx::NativeViewAccessible>(NULL);
+}
+
+BrowserAccessibilityManager*
+RenderWidgetHostViewAura::GetOrCreateBrowserAccessibilityManager() {
+  BrowserAccessibilityManager* manager = GetBrowserAccessibilityManager();
+  if (manager)
+    return manager;
+
+#if defined(OS_WIN)
+  aura::RootWindow* root_window = window_->GetRootWindow();
+  if (!root_window)
+    return NULL;
+  HWND hwnd = root_window->GetAcceleratedWidget();
+
+  // The accessible_parent may be NULL at this point. The WebContents will pass
+  // it down to this instance (by way of the RenderViewHost and
+  // RenderWidgetHost) when it is known. This instance will then set it on its
+  // BrowserAccessibilityManager.
+  gfx::NativeViewAccessible accessible_parent =
+      host_->GetParentNativeViewAccessible();
+
+  manager = new BrowserAccessibilityManagerWin(
+      hwnd, accessible_parent,
+      BrowserAccessibilityManagerWin::GetEmptyDocument(), this);
+#else
+  manager = BrowserAccessibilityManager::Create(
+      BrowserAccessibilityManager::GetEmptyDocument(), this);
+#endif
+
+  SetBrowserAccessibilityManager(manager);
+  return manager;
+}
+
+void RenderWidgetHostViewAura::MovePluginWindows(
+    const gfx::Vector2d& scroll_offset,
+    const std::vector<WebPluginGeometry>& plugin_window_moves) {
+#if defined(OS_WIN)
+  // We need to clip the rectangle to the tab's viewport, otherwise we will draw
+  // over the browser UI.
+  if (!window_->GetRootWindow()) {
+    DCHECK(plugin_window_moves.empty());
+    return;
+  }
+  HWND parent = window_->GetRootWindow()->GetAcceleratedWidget();
+  gfx::Rect view_bounds = window_->GetBoundsInRootWindow();
+  std::vector<WebPluginGeometry> moves = plugin_window_moves;
+
+  gfx::Rect view_port(scroll_offset.x(), scroll_offset.y(), view_bounds.width(),
+                      view_bounds.height());
+
+  for (size_t i = 0; i < moves.size(); ++i) {
+    gfx::Rect clip(moves[i].clip_rect);
+    gfx::Vector2d view_port_offset(
+        moves[i].window_rect.OffsetFromOrigin() + scroll_offset);
+    clip.Offset(view_port_offset);
+    clip.Intersect(view_port);
+    clip.Offset(-view_port_offset);
+    moves[i].clip_rect = clip;
+
+    moves[i].window_rect.Offset(view_bounds.OffsetFromOrigin());
+
+    plugin_window_moves_[moves[i].window] = moves[i];
+
+    // transient_rects_ and constrained_rects_ are relative to the root window.
+    // We want to convert them to be relative to the plugin window.
+    std::vector<gfx::Rect> cutout_rects;
+    cutout_rects.assign(transient_rects_.begin(), transient_rects_.end());
+    cutout_rects.insert(cutout_rects.end(), constrained_rects_.begin(),
+                        constrained_rects_.end());
+    for (size_t j = 0; j < cutout_rects.size(); ++j) {
+      gfx::Rect offset_cutout = cutout_rects[j];
+      offset_cutout -= moves[i].window_rect.OffsetFromOrigin();
+      moves[i].cutout_rects.push_back(offset_cutout);
+    }
+  }
+
+  MovePluginWindowsHelper(parent, moves);
+
+  // Make sure each plugin window (or its wrapper if it exists) has a pointer to
+  // |this|.
+  for (size_t i = 0; i < moves.size(); ++i) {
+    HWND window = moves[i].window;
+    if (GetParent(window) != parent) {
+      window = GetParent(window);
+      DCHECK(GetParent(window) == parent);
+    }
+    if (!GetProp(window, kWidgetOwnerProperty))
+      CHECK(SetProp(window, kWidgetOwnerProperty, this));
+  }
+#endif  // defined(OS_WIN)
+}
+
+void RenderWidgetHostViewAura::Focus() {
+  // Make sure we have a FocusClient before attempting to Focus(). In some
+  // situations we may not yet be in a valid Window hierarchy (such as reloading
+  // after out of memory discarded the tab).
+  aura::client::FocusClient* client = aura::client::GetFocusClient(window_);
+  if (client)
+    window_->Focus();
+}
+
+void RenderWidgetHostViewAura::Blur() {
+  window_->Blur();
+}
+
+bool RenderWidgetHostViewAura::HasFocus() const {
+  return window_->HasFocus();
+}
+
+bool RenderWidgetHostViewAura::IsSurfaceAvailableForCopy() const {
+  return window_->layer()->has_external_content() ||
+         !!host_->GetBackingStore(false);
+}
+
+void RenderWidgetHostViewAura::Show() {
+  window_->Show();
+}
+
+void RenderWidgetHostViewAura::Hide() {
+  window_->Hide();
+}
+
+bool RenderWidgetHostViewAura::IsShowing() {
+  return window_->IsVisible();
+}
+
+gfx::Rect RenderWidgetHostViewAura::GetViewBounds() const {
+  // This is the size that we want the renderer to produce. While we're waiting
+  // for the correct frame (i.e. during a resize), don't change the size so that
+  // we don't pipeline more resizes than we can handle.
+  gfx::Rect bounds(window_->GetBoundsInScreen());
+  if (resize_lock_.get())
+    return gfx::Rect(bounds.origin(), resize_lock_->expected_size());
+  else
+    return bounds;
+}
+
+void RenderWidgetHostViewAura::SetBackground(const SkBitmap& background) {
+  RenderWidgetHostViewBase::SetBackground(background);
+  host_->SetBackground(background);
+  window_->layer()->SetFillsBoundsOpaquely(background.isOpaque());
+}
+
+#if defined(OS_WIN)
+gfx::NativeViewAccessible
+RenderWidgetHostViewAura::AccessibleObjectFromChildId(long child_id) {
+  BrowserAccessibilityManager* manager = GetBrowserAccessibilityManager();
+  if (!manager)
+    return NULL;
+
+  return manager->ToBrowserAccessibilityManagerWin()->GetFromUniqueIdWin(
+      child_id);
+}
+#endif  // defined(OS_WIN)
+
+void RenderWidgetHostViewAura::UpdateCursor(const WebCursor& cursor) {
+  current_cursor_ = cursor;
+  const gfx::Display display = gfx::Screen::GetScreenFor(window_)->
+      GetDisplayNearestWindow(window_);
+  current_cursor_.SetDeviceScaleFactor(display.device_scale_factor());
+  UpdateCursorIfOverSelf();
+}
+
+void RenderWidgetHostViewAura::SetIsLoading(bool is_loading) {
+  if (is_loading_ && !is_loading && paint_observer_)
+    paint_observer_->OnPageLoadComplete();
+  is_loading_ = is_loading;
+  UpdateCursorIfOverSelf();
+}
+
+void RenderWidgetHostViewAura::TextInputTypeChanged(
+    ui::TextInputType type,
+    bool can_compose_inline,
+    ui::TextInputMode input_mode) {
+  if (text_input_type_ != type ||
+      can_compose_inline_ != can_compose_inline) {
+    text_input_type_ = type;
+    can_compose_inline_ = can_compose_inline;
+    if (GetInputMethod())
+      GetInputMethod()->OnTextInputTypeChanged(this);
+    if (touch_editing_client_)
+      touch_editing_client_->OnTextInputTypeChanged(text_input_type_);
+  }
+}
+
+void RenderWidgetHostViewAura::ImeCancelComposition() {
+  if (GetInputMethod())
+    GetInputMethod()->CancelComposition(this);
+  has_composition_text_ = false;
+}
+
+void RenderWidgetHostViewAura::ImeCompositionRangeChanged(
+    const ui::Range& range,
+    const std::vector<gfx::Rect>& character_bounds) {
+  composition_character_bounds_ = character_bounds;
+}
+
+void RenderWidgetHostViewAura::DidUpdateBackingStore(
+    const gfx::Rect& scroll_rect,
+    const gfx::Vector2d& scroll_delta,
+    const std::vector<gfx::Rect>& copy_rects,
+    const ui::LatencyInfo& latency_info) {
+  if (accelerated_compositing_state_changed_)
+    UpdateExternalTexture();
+
+  software_latency_info_.MergeWith(latency_info);
+
+  // Use the state of the RenderWidgetHost and not the window as the two may
+  // differ. In particular if the window is hidden but the renderer isn't and we
+  // ignore the update and the window is made visible again the layer isn't
+  // marked as dirty and we show the wrong thing.
+  // We do this after UpdateExternalTexture() so that when we become visible
+  // we're not drawing a stale texture.
+  if (host_->is_hidden())
+    return;
+
+  gfx::Rect clip_rect;
+  if (paint_canvas_) {
+    SkRect sk_clip_rect;
+    if (paint_canvas_->sk_canvas()->getClipBounds(&sk_clip_rect))
+      clip_rect = gfx::ToEnclosingRect(gfx::SkRectToRectF(sk_clip_rect));
+  }
+
+  if (!scroll_rect.IsEmpty())
+    SchedulePaintIfNotInClip(scroll_rect, clip_rect);
+
+#if defined(OS_WIN)
+  aura::RootWindow* root_window = window_->GetRootWindow();
+#endif
+  for (size_t i = 0; i < copy_rects.size(); ++i) {
+    gfx::Rect rect = gfx::SubtractRects(copy_rects[i], scroll_rect);
+    if (rect.IsEmpty())
+      continue;
+
+    SchedulePaintIfNotInClip(rect, clip_rect);
+
+#if defined(OS_WIN)
+    if (root_window) {
+      // Send the invalid rect in screen coordinates.
+      gfx::Rect screen_rect = GetViewBounds();
+      gfx::Rect invalid_screen_rect(rect);
+      invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
+      HWND hwnd = root_window->GetAcceleratedWidget();
+      PaintPluginWindowsHelper(hwnd, invalid_screen_rect);
+    }
+#endif  // defined(OS_WIN)
+  }
+}
+
+void RenderWidgetHostViewAura::RenderProcessGone(base::TerminationStatus status,
+                                                 int error_code) {
+  UpdateCursorIfOverSelf();
+  Destroy();
+}
+
+void RenderWidgetHostViewAura::Destroy() {
+  // Beware, this function is not called on all destruction paths. It will
+  // implicitly end up calling ~RenderWidgetHostViewAura though, so all
+  // destruction/cleanup code should happen there, not here.
+  in_shutdown_ = true;
+  delete window_;
+}
+
+void RenderWidgetHostViewAura::SetTooltipText(const string16& tooltip_text) {
+  tooltip_ = tooltip_text;
+  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::client::TooltipClient* tooltip_client =
+      aura::client::GetTooltipClient(root_window);
+  if (tooltip_client) {
+    tooltip_client->UpdateTooltip(window_);
+    // Content tooltips should be visible indefinitely.
+    tooltip_client->SetTooltipShownTimeout(window_, 0);
+  }
+}
+
+void RenderWidgetHostViewAura::SelectionChanged(const string16& text,
+                                                size_t offset,
+                                                const ui::Range& range) {
+  RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
+
+#if defined(USE_X11) && !defined(OS_CHROMEOS)
+  if (text.empty() || range.is_empty())
+    return;
+
+  // Set the BUFFER_SELECTION to the ui::Clipboard.
+  ui::ScopedClipboardWriter clipboard_writer(
+      ui::Clipboard::GetForCurrentThread(),
+      ui::Clipboard::BUFFER_SELECTION);
+  clipboard_writer.WriteText(text);
+#endif  // defined(USE_X11) && !defined(OS_CHROMEOS)
+}
+
+void RenderWidgetHostViewAura::SelectionBoundsChanged(
+    const ViewHostMsg_SelectionBounds_Params& params) {
+  if (selection_anchor_rect_ == params.anchor_rect &&
+      selection_focus_rect_ == params.focus_rect)
+    return;
+
+  selection_anchor_rect_ = params.anchor_rect;
+  selection_focus_rect_ = params.focus_rect;
+
+  if (GetInputMethod())
+    GetInputMethod()->OnCaretBoundsChanged(this);
+
+  if (touch_editing_client_) {
+    touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_rect_,
+        selection_focus_rect_);
+  }
+}
+
+void RenderWidgetHostViewAura::ScrollOffsetChanged() {
+  aura::RootWindow* root = window_->GetRootWindow();
+  if (!root)
+    return;
+  aura::client::CursorClient* cursor_client =
+      aura::client::GetCursorClient(root);
+  if (cursor_client && !cursor_client->IsCursorVisible())
+    cursor_client->DisableMouseEvents();
+}
+
+BackingStore* RenderWidgetHostViewAura::AllocBackingStore(
+    const gfx::Size& size) {
+  return new BackingStoreAura(host_, size);
+}
+
+void RenderWidgetHostViewAura::CopyFromCompositingSurface(
+    const gfx::Rect& src_subrect,
+    const gfx::Size& dst_size,
+    const base::Callback<void(bool, const SkBitmap&)>& callback) {
+  if (!window_->layer()->has_external_content()) {
+    callback.Run(false, SkBitmap());
+    return;
+  }
+
+  const gfx::Size& dst_size_in_pixel = ConvertViewSizeToPixel(this, dst_size);
+
+  scoped_ptr<cc::CopyOutputRequest> request =
+      cc::CopyOutputRequest::CreateRequest(base::Bind(
+          &RenderWidgetHostViewAura::CopyFromCompositingSurfaceHasResult,
+          dst_size_in_pixel,
+          callback));
+  request->set_area(src_subrect);
+  window_->layer()->RequestCopyOfOutput(request.Pass());
+}
+
+void RenderWidgetHostViewAura::CopyFromCompositingSurfaceToVideoFrame(
+      const gfx::Rect& src_subrect,
+      const scoped_refptr<media::VideoFrame>& target,
+      const base::Callback<void(bool)>& callback) {
+  if (!window_->layer()->has_external_content()) {
+    callback.Run(false);
+    return;
+  }
+
+  scoped_ptr<cc::CopyOutputRequest> request =
+      cc::CopyOutputRequest::CreateRequest(base::Bind(
+          &RenderWidgetHostViewAura::
+              CopyFromCompositingSurfaceHasResultForVideo,
+          AsWeakPtr(),  // For caching the ReadbackYUVInterface on this class.
+          target,
+          callback));
+  request->set_area(src_subrect);
+  window_->layer()->RequestCopyOfOutput(request.Pass());
+}
+
+bool RenderWidgetHostViewAura::CanCopyToVideoFrame() const {
+  // TODO(skaslev): Implement this path for s/w compositing.
+  return window_->layer()->has_external_content() &&
+         host_->is_accelerated_compositing_active();
+}
+
+bool RenderWidgetHostViewAura::CanSubscribeFrame() const {
+  return true;
+}
+
+void RenderWidgetHostViewAura::BeginFrameSubscription(
+    scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
+  frame_subscriber_ = subscriber.Pass();
+}
+
+void RenderWidgetHostViewAura::EndFrameSubscription() {
+  frame_subscriber_.reset();
+}
+
+
+void RenderWidgetHostViewAura::OnAcceleratedCompositingStateChange() {
+  // Delay processing the state change until we either get a software frame if
+  // switching to software mode or receive a buffers swapped notification
+  // if switching to accelerated mode.
+  // Sometimes (e.g. on a page load) the renderer will spuriously disable then
+  // re-enable accelerated compositing, causing us to flash.
+  // TODO(piman): factor the enable/disable accelerated compositing message into
+  // the UpdateRect/AcceleratedSurfaceBuffersSwapped messages so that we have
+  // fewer inconsistent temporary states.
+  accelerated_compositing_state_changed_ = true;
+}
+
+bool RenderWidgetHostViewAura::ShouldSkipFrame(gfx::Size size_in_dip) const {
+  if (can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
+      can_lock_compositor_ == NO_PENDING_COMMIT ||
+      !resize_lock_.get())
+    return false;
+
+  return size_in_dip != resize_lock_->expected_size();
+}
+
+void RenderWidgetHostViewAura::InternalSetBounds(const gfx::Rect& rect) {
   if (HasDisplayPropertyChanged(window_))
     host_->InvalidateScreenInfo();
 
   window_->SetBounds(rect);
   host_->WasResized();
   MaybeCreateResizeLock();
   if (touch_editing_client_) {
     touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_rect_,
         selection_focus_rect_);
   }
@@ skipping 28 matching lines @@
       if (can_lock_compositor_ == YES)
         can_lock_compositor_ = YES_DID_LOCK;
 
       resize_lock_.reset(new ResizeLock(root_window, desired_size,
                                         defer_compositor_lock));
 #endif
     }
   }
 }
 
-gfx::NativeView RenderWidgetHostViewAura::GetNativeView() const {
-  return window_;
-}
-
-gfx::NativeViewId RenderWidgetHostViewAura::GetNativeViewId() const {
-#if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (root_window) {
-    HWND window = root_window->GetAcceleratedWidget();
-    return reinterpret_cast<gfx::NativeViewId>(window);
-  }
-#endif
-  return static_cast<gfx::NativeViewId>(NULL);
-}
-
-gfx::NativeViewAccessible RenderWidgetHostViewAura::GetNativeViewAccessible() {
-#if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (!root_window)
-    return static_cast<gfx::NativeViewAccessible>(NULL);
-  HWND hwnd = root_window->GetAcceleratedWidget();
-
-  BrowserAccessibilityManager* manager =
-      GetOrCreateBrowserAccessibilityManager();
-  if (manager)
-    return manager->GetRoot()->ToBrowserAccessibilityWin();
-#endif
-
-  NOTIMPLEMENTED();
-  return static_cast<gfx::NativeViewAccessible>(NULL);
-}
-
-BrowserAccessibilityManager*
-RenderWidgetHostViewAura::GetOrCreateBrowserAccessibilityManager() {
-  BrowserAccessibilityManager* manager = GetBrowserAccessibilityManager();
-  if (manager)
-    return manager;
-
-#if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (!root_window)
-    return NULL;
-  HWND hwnd = root_window->GetAcceleratedWidget();
-
-  // The accessible_parent may be NULL at this point. The WebContents will pass
-  // it down to this instance (by way of the RenderViewHost and
-  // RenderWidgetHost) when it is known. This instance will then set it on its
-  // BrowserAccessibilityManager.
-  gfx::NativeViewAccessible accessible_parent =
-      host_->GetParentNativeViewAccessible();
-
-  manager = new BrowserAccessibilityManagerWin(
-      hwnd, accessible_parent,
-      BrowserAccessibilityManagerWin::GetEmptyDocument(), this);
-#else
-  manager = BrowserAccessibilityManager::Create(
-      BrowserAccessibilityManager::GetEmptyDocument(), this);
-#endif
-
-  SetBrowserAccessibilityManager(manager);
-  return manager;
-}
-
-void RenderWidgetHostViewAura::MovePluginWindows(
-    const gfx::Vector2d& scroll_offset,
-    const std::vector<WebPluginGeometry>& plugin_window_moves) {
-#if defined(OS_WIN)
-  // We need to clip the rectangle to the tab's viewport, otherwise we will draw
-  // over the browser UI.
-  if (!window_->GetRootWindow()) {
-    DCHECK(plugin_window_moves.empty());
-    return;
-  }
-  HWND parent = window_->GetRootWindow()->GetAcceleratedWidget();
-  gfx::Rect view_bounds = window_->GetBoundsInRootWindow();
-  std::vector<WebPluginGeometry> moves = plugin_window_moves;
-
-  gfx::Rect view_port(scroll_offset.x(), scroll_offset.y(), view_bounds.width(),
-                      view_bounds.height());
-
-  for (size_t i = 0; i < moves.size(); ++i) {
-    gfx::Rect clip(moves[i].clip_rect);
-    gfx::Vector2d view_port_offset(
-        moves[i].window_rect.OffsetFromOrigin() + scroll_offset);
-    clip.Offset(view_port_offset);
-    clip.Intersect(view_port);
-    clip.Offset(-view_port_offset);
-    moves[i].clip_rect = clip;
-
-    moves[i].window_rect.Offset(view_bounds.OffsetFromOrigin());
-
-    plugin_window_moves_[moves[i].window] = moves[i];
-
-    // transient_rects_ and constrained_rects_ are relative to the root window.
-    // We want to convert them to be relative to the plugin window.
-    std::vector<gfx::Rect> cutout_rects;
-    cutout_rects.assign(transient_rects_.begin(), transient_rects_.end());
-    cutout_rects.insert(cutout_rects.end(), constrained_rects_.begin(),
-                        constrained_rects_.end());
-    for (size_t j = 0; j < cutout_rects.size(); ++j) {
-      gfx::Rect offset_cutout = cutout_rects[j];
-      offset_cutout -= moves[i].window_rect.OffsetFromOrigin();
-      moves[i].cutout_rects.push_back(offset_cutout);
-    }
-  }
-
-  MovePluginWindowsHelper(parent, moves);
-
-  // Make sure each plugin window (or its wrapper if it exists) has a pointer to
-  // |this|.
-  for (size_t i = 0; i < moves.size(); ++i) {
-    HWND window = moves[i].window;
-    if (GetParent(window) != parent) {
-      window = GetParent(window);
-      DCHECK(GetParent(window) == parent);
-    }
-    if (!GetProp(window, kWidgetOwnerProperty))
-      CHECK(SetProp(window, kWidgetOwnerProperty, this));
-  }
-#endif  // defined(OS_WIN)
-}
-
-void RenderWidgetHostViewAura::Focus() {
-  // Make sure we have a FocusClient before attempting to Focus(). In some
-  // situations we may not yet be in a valid Window hierarchy (such as reloading
-  // after out of memory discarded the tab).
-  aura::client::FocusClient* client = aura::client::GetFocusClient(window_);
-  if (client)
-    window_->Focus();
-}
-
-void RenderWidgetHostViewAura::Blur() {
-  window_->Blur();
-}
-
-bool RenderWidgetHostViewAura::HasFocus() const {
-  return window_->HasFocus();
-}
-
-bool RenderWidgetHostViewAura::IsSurfaceAvailableForCopy() const {
-  return window_->layer()->has_external_content() ||
-         !!host_->GetBackingStore(false);
-}
-
-void RenderWidgetHostViewAura::Show() {
-  window_->Show();
-}
-
-void RenderWidgetHostViewAura::Hide() {
-  window_->Hide();
-}
-
-bool RenderWidgetHostViewAura::IsShowing() {
-  return window_->IsVisible();
-}
-
-gfx::Rect RenderWidgetHostViewAura::GetViewBounds() const {
-  // This is the size that we want the renderer to produce. While we're waiting
-  // for the correct frame (i.e. during a resize), don't change the size so that
-  // we don't pipeline more resizes than we can handle.
-  gfx::Rect bounds(window_->GetBoundsInScreen());
-  if (resize_lock_.get())
-    return gfx::Rect(bounds.origin(), resize_lock_->expected_size());
-  else
-    return bounds;
-}
-
-void RenderWidgetHostViewAura::SetBackground(const SkBitmap& background) {
-  RenderWidgetHostViewBase::SetBackground(background);
-  host_->SetBackground(background);
-  window_->layer()->SetFillsBoundsOpaquely(background.isOpaque());
-}
-
-#if defined(OS_WIN)
-gfx::NativeViewAccessible
-RenderWidgetHostViewAura::AccessibleObjectFromChildId(long child_id) {
-  BrowserAccessibilityManager* manager = GetBrowserAccessibilityManager();
-  if (!manager)
-    return NULL;
-
-  return manager->ToBrowserAccessibilityManagerWin()->GetFromUniqueIdWin(
-      child_id);
-}
-#endif  // defined(OS_WIN)
-
-void RenderWidgetHostViewAura::UpdateCursor(const WebCursor& cursor) {
-  current_cursor_ = cursor;
-  const gfx::Display display = gfx::Screen::GetScreenFor(window_)->
-      GetDisplayNearestWindow(window_);
-  current_cursor_.SetDeviceScaleFactor(display.device_scale_factor());
-  UpdateCursorIfOverSelf();
-}
-
-void RenderWidgetHostViewAura::SetIsLoading(bool is_loading) {
-  if (is_loading_ && !is_loading && paint_observer_)
-    paint_observer_->OnPageLoadComplete();
-  is_loading_ = is_loading;
-  UpdateCursorIfOverSelf();
-}
-
-void RenderWidgetHostViewAura::TextInputTypeChanged(
-    ui::TextInputType type,
-    bool can_compose_inline,
-    ui::TextInputMode input_mode) {
-  if (text_input_type_ != type ||
-      can_compose_inline_ != can_compose_inline) {
-    text_input_type_ = type;
-    can_compose_inline_ = can_compose_inline;
-    if (GetInputMethod())
-      GetInputMethod()->OnTextInputTypeChanged(this);
-    if (touch_editing_client_)
-      touch_editing_client_->OnTextInputTypeChanged(text_input_type_);
-  }
-}
-
-void RenderWidgetHostViewAura::ImeCancelComposition() {
-  if (GetInputMethod())
-    GetInputMethod()->CancelComposition(this);
-  has_composition_text_ = false;
-}
-
-void RenderWidgetHostViewAura::ImeCompositionRangeChanged(
-    const ui::Range& range,
-    const std::vector<gfx::Rect>& character_bounds) {
-  composition_character_bounds_ = character_bounds;
-}
-
-void RenderWidgetHostViewAura::DidUpdateBackingStore(
-    const gfx::Rect& scroll_rect,
-    const gfx::Vector2d& scroll_delta,
-    const std::vector<gfx::Rect>& copy_rects,
-    const ui::LatencyInfo& latency_info) {
-  if (accelerated_compositing_state_changed_)
-    UpdateExternalTexture();
-
-  software_latency_info_.MergeWith(latency_info);
-
-  // Use the state of the RenderWidgetHost and not the window as the two may
-  // differ. In particular if the window is hidden but the renderer isn't and we
-  // ignore the update and the window is made visible again the layer isn't
-  // marked as dirty and we show the wrong thing.
-  // We do this after UpdateExternalTexture() so that when we become visible
-  // we're not drawing a stale texture.
-  if (host_->is_hidden())
-    return;
-
-  gfx::Rect clip_rect;
-  if (paint_canvas_) {
-    SkRect sk_clip_rect;
-    if (paint_canvas_->sk_canvas()->getClipBounds(&sk_clip_rect))
-      clip_rect = gfx::ToEnclosingRect(gfx::SkRectToRectF(sk_clip_rect));
-  }
-
-  if (!scroll_rect.IsEmpty())
-    SchedulePaintIfNotInClip(scroll_rect, clip_rect);
-
-#if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
-#endif
-  for (size_t i = 0; i < copy_rects.size(); ++i) {
-    gfx::Rect rect = gfx::SubtractRects(copy_rects[i], scroll_rect);
-    if (rect.IsEmpty())
-      continue;
-
-    SchedulePaintIfNotInClip(rect, clip_rect);
-
-#if defined(OS_WIN)
-    if (root_window) {
-      // Send the invalid rect in screen coordinates.
-      gfx::Rect screen_rect = GetViewBounds();
-      gfx::Rect invalid_screen_rect(rect);
-      invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
-      HWND hwnd = root_window->GetAcceleratedWidget();
-      PaintPluginWindowsHelper(hwnd, invalid_screen_rect);
-    }
-#endif  // defined(OS_WIN)
-  }
-}
-
-void RenderWidgetHostViewAura::RenderProcessGone(base::TerminationStatus status,
-                                                 int error_code) {
-  UpdateCursorIfOverSelf();
-  Destroy();
-}
-
-void RenderWidgetHostViewAura::Destroy() {
-  // Beware, this function is not called on all destruction paths. It will
-  // implicitly end up calling ~RenderWidgetHostViewAura though, so all
-  // destruction/cleanup code should happen there, not here.
-  in_shutdown_ = true;
-  delete window_;
-}
-
-void RenderWidgetHostViewAura::SetTooltipText(const string16& tooltip_text) {
-  tooltip_ = tooltip_text;
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  aura::client::TooltipClient* tooltip_client =
-      aura::client::GetTooltipClient(root_window);
-  if (tooltip_client) {
-    tooltip_client->UpdateTooltip(window_);
-    // Content tooltips should be visible indefinitely.
-    tooltip_client->SetTooltipShownTimeout(window_, 0);
-  }
-}
-
-void RenderWidgetHostViewAura::SelectionChanged(const string16& text,
-                                                size_t offset,
-                                                const ui::Range& range) {
-  RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
-
-#if defined(USE_X11) && !defined(OS_CHROMEOS)
-  if (text.empty() || range.is_empty())
-    return;
-
-  // Set the BUFFER_SELECTION to the ui::Clipboard.
-  ui::ScopedClipboardWriter clipboard_writer(
-      ui::Clipboard::GetForCurrentThread(),
-      ui::Clipboard::BUFFER_SELECTION);
-  clipboard_writer.WriteText(text);
-#endif  // defined(USE_X11) && !defined(OS_CHROMEOS)
-}
-
-void RenderWidgetHostViewAura::SelectionBoundsChanged(
-    const ViewHostMsg_SelectionBounds_Params& params) {
-  if (selection_anchor_rect_ == params.anchor_rect &&
-      selection_focus_rect_ == params.focus_rect)
-    return;
-
-  selection_anchor_rect_ = params.anchor_rect;
-  selection_focus_rect_ = params.focus_rect;
-
-  if (GetInputMethod())
-    GetInputMethod()->OnCaretBoundsChanged(this);
-
-  if (touch_editing_client_) {
-    touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_rect_,
-        selection_focus_rect_);
-  }
-}
-
-void RenderWidgetHostViewAura::ScrollOffsetChanged() {
-  aura::RootWindow* root = window_->GetRootWindow();
-  if (!root)
-    return;
-  aura::client::CursorClient* cursor_client =
-      aura::client::GetCursorClient(root);
-  if (cursor_client && !cursor_client->IsCursorVisible())
-    cursor_client->DisableMouseEvents();
-}
-
-BackingStore* RenderWidgetHostViewAura::AllocBackingStore(
-    const gfx::Size& size) {
-  return new BackingStoreAura(host_, size);
-}
-
-void RenderWidgetHostViewAura::CopyFromCompositingSurface(
-    const gfx::Rect& src_subrect,
-    const gfx::Size& dst_size,
-    const base::Callback<void(bool, const SkBitmap&)>& callback) {
-  if (!window_->layer()->has_external_content()) {
-    callback.Run(false, SkBitmap());
-    return;
-  }
-
-  const gfx::Size& dst_size_in_pixel = ConvertViewSizeToPixel(this, dst_size);
-  scoped_ptr<cc::CopyOutputRequest> request =
-      cc::CopyOutputRequest::CreateRequest(base::Bind(
-          &RenderWidgetHostViewAura::CopyFromCompositingSurfaceHasResult,
-          dst_size_in_pixel,
-          callback));
-  request->set_area(src_subrect);
-  window_->layer()->RequestCopyOfOutput(request.Pass());
-}
-
-void RenderWidgetHostViewAura::CopyFromCompositingSurfaceToVideoFrame(
-      const gfx::Rect& src_subrect,
-      const scoped_refptr<media::VideoFrame>& target,
-      const base::Callback<void(bool)>& callback) {
-  if (!window_->layer()->has_external_content()) {
-    callback.Run(false);
-    return;
-  }
-
-  scoped_ptr<cc::CopyOutputRequest> request =
-      cc::CopyOutputRequest::CreateRequest(base::Bind(
-          &RenderWidgetHostViewAura::
-              CopyFromCompositingSurfaceHasResultForVideo,
-          AsWeakPtr(),  // For caching the ReadbackYUVInterface on this class.
-          target,
-          callback));
-  request->set_area(src_subrect);
-  window_->layer()->RequestCopyOfOutput(request.Pass());
-}
-
-bool RenderWidgetHostViewAura::CanCopyToVideoFrame() const {
-  // TODO(skaslev): Implement this path for s/w compositing.
-  return window_->layer()->has_external_content() &&
-         host_->is_accelerated_compositing_active();
-}
-
-bool RenderWidgetHostViewAura::CanSubscribeFrame() const {
-  return true;
-}
-
-void RenderWidgetHostViewAura::BeginFrameSubscription(
-    scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
-  frame_subscriber_ = subscriber.Pass();
-}
-
-void RenderWidgetHostViewAura::EndFrameSubscription() {
-  frame_subscriber_.reset();
-}
-
-
-void RenderWidgetHostViewAura::OnAcceleratedCompositingStateChange() {
-  // Delay processing the state change until we either get a software frame if
-  // switching to software mode or receive a buffers swapped notification
-  // if switching to accelerated mode.
-  // Sometimes (e.g. on a page load) the renderer will spuriously disable then
-  // re-enable accelerated compositing, causing us to flash.
-  // TODO(piman): factor the enable/disable accelerated compositing message into
-  // the UpdateRect/AcceleratedSurfaceBuffersSwapped messages so that we have
-  // fewer inconsistent temporary states.
-  accelerated_compositing_state_changed_ = true;
-}
-
-bool RenderWidgetHostViewAura::ShouldSkipFrame(gfx::Size size_in_dip) const {
-  if (can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
-      can_lock_compositor_ == NO_PENDING_COMMIT ||
-      !resize_lock_.get())
-    return false;
-
-  return size_in_dip != resize_lock_->expected_size();
-}
-
 void RenderWidgetHostViewAura::CheckResizeLock() {
   if (!resize_lock_ || resize_lock_->expected_size() != current_frame_size_)
     return;
 
   // Since we got the size we were looking for, unlock the compositor. But delay
   // the release of the lock until we've kicked a frame with the new texture, to
   // avoid resizing the UI before we have a chance to draw a "good" frame.
   resize_lock_->UnlockCompositor();
   ui::Compositor* compositor = GetCompositor();
   if (compositor) {
@@ skipping 1879 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content