Don't set view_screen_rect_ on RequestMove ACK

content/renderer/render_widget.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/renderer/render_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 646 matching lines @@
     std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
         compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
     compositor_->SetNeedsForcedRedraw();
   }
   ScheduleComposite();
 }
 
 void RenderWidget::OnRequestMoveAck() {
   DCHECK(pending_window_rect_count_);
   pending_window_rect_count_--;
-  if (!pending_window_rect_count_)
-    view_screen_rect_ = pending_window_rect_;
 }
 
 GURL RenderWidget::GetURLForGraphicsContext3D() {
   return GURL();
 }
 
 void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info,
                                       InputEventDispatchType dispatch_type) {
   if (!input_event)
@@ skipping 625 matching lines @@
   screen_metrics_emulator_.reset();
   WillCloseLayerTreeView();
   compositor_.reset();
   if (webwidget_) {
     webwidget_->close();
     webwidget_ = nullptr;
   }
 }
 
 WebRect RenderWidget::windowRect() {
-  if (pending_window_rect_count_)
+  if (pending_window_rect_count_) {
+    // NOTE(mbelshe): If there is a pending_window_rect_, then getting
+    // the RootWindowRect is probably going to return wrong results since the
+    // browser may not have processed the Move yet.  There isn't really anything
+    // good to do in this case, and it shouldn't happen - since this size is
+    // only really needed for windowToScreen, which is only used for Popups.
     return pending_window_rect_;
+  }
 
-  return view_screen_rect_;
+  return window_screen_rect_;
+}
+
+WebRect RenderWidget::viewRect() {
+    return view_screen_rect_;
 }
 
 void RenderWidget::setToolTipText(const blink::WebString& text,
                                   WebTextDirection hint) {
   Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
 }
 
 void RenderWidget::setWindowRect(const WebRect& rect_in_screen) {
   WebRect window_rect = rect_in_screen;
   if (popup_origin_scale_for_emulation_) {
@@ skipping 12 matching lines @@
       initial_rect_ = window_rect;
     }
   } else {
     SetWindowRectSynchronously(window_rect);
   }
 }
 
 void RenderWidget::SetPendingWindowRect(const WebRect& rect) {
   pending_window_rect_ = rect;
   pending_window_rect_count_++;
-}
 
-gfx::Rect RenderWidget::RootWindowRect() {
-  if (pending_window_rect_count_) {
-    // NOTE(mbelshe): If there is a pending_window_rect_, then getting
-    // the RootWindowRect is probably going to return wrong results since the
-    // browser may not have processed the Move yet.  There isn't really anything
-    // good to do in this case, and it shouldn't happen - since this size is
-    // only really needed for windowToScreen, which is only used for Popups.
-    return pending_window_rect_;
+  // Popups don't get size updates back from the browser so just store the set
+  // values.
+  if (popup_type_ != blink::WebPopupTypeNone) {
+      window_screen_rect_ = rect;
+      view_screen_rect_ = rect;
   }
-
-  return window_screen_rect_;
 }
 
 WebRect RenderWidget::windowResizerRect() {
   return resizer_rect_;
 }
 
 void RenderWidget::OnImeSetComposition(
     const base::string16& text,
     const std::vector<WebCompositionUnderline>& underlines,
     const gfx::Range& replacement_range,
@@ skipping 97 matching lines @@
     screen_metrics_emulator_->OnUpdateScreenRects(view_screen_rect,
                                                   window_screen_rect);
   } else {
     SetScreenRects(view_screen_rect, window_screen_rect);
   }
   Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
 }
 
 void RenderWidget::OnUpdateWindowScreenRect(
     const gfx::Rect& window_screen_rect) {
-  if (screen_metrics_emulator_) {
+  if (screen_metrics_emulator_)
     screen_metrics_emulator_->OnUpdateWindowScreenRect(window_screen_rect);
-  } else {
+  else
     window_screen_rect_ = window_screen_rect;
-  }
 }
 
 void RenderWidget::OnSetSurfaceClientId(uint32_t surface_id_namespace) {
   if (compositor_)
     compositor_->SetSurfaceClientId(surface_id_namespace);
 }
 
 void RenderWidget::OnHandleCompositorProto(const std::vector<uint8_t>& proto) {
   if (compositor_)
     compositor_->OnHandleCompositorProto(proto);
@@ skipping 313 matching lines @@
 }
 
 void RenderWidget::DidAutoResize(const gfx::Size& new_size) {
   WebRect new_size_in_window(0, 0, new_size.width(), new_size.height());
   convertViewportToWindow(&new_size_in_window);
   if (size_.width() != new_size_in_window.width ||
       size_.height() != new_size_in_window.height) {
     size_ = gfx::Size(new_size_in_window.width, new_size_in_window.height);
 
     if (resizing_mode_selector_->is_synchronous_mode()) {
-      gfx::Rect new_pos(RootWindowRect().x(), RootWindowRect().y(),
+      gfx::Rect new_pos(windowRect().x, windowRect().y,
                         size_.width(), size_.height());
       view_screen_rect_ = new_pos;
       window_screen_rect_ = new_pos;
     }
 
     AutoResizeCompositor();
 
     if (!resizing_mode_selector_->is_synchronous_mode())
       need_update_rect_for_auto_resize_ = true;
   }
@@ skipping 270 matching lines @@
 void RenderWidget::requestPointerUnlock() {
   mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
 }
 
 bool RenderWidget::isPointerLocked() {
   return mouse_lock_dispatcher_->IsMouseLockedTo(
       webwidget_mouse_lock_target_.get());
 }
 
 }  // namespace content