Revert of Send resize event when the screen info changes.

content/browser/renderer_host/render_widget_host_impl.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_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 152 matching lines @@
       hung_renderer_delay_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       delegate_(delegate),
       process_(process),
       routing_id_(routing_id),
       surface_id_(0),
       is_loading_(false),
       is_hidden_(hidden),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
-      screen_info_out_of_date_(true),
+      screen_info_out_of_date_(false),
       auto_resize_enabled_(false),
       waiting_for_screen_rects_ack_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_flight_event_count_(0),
       in_get_backing_store_(false),
       ignore_input_events_(false),
       input_method_active_(false),
       text_direction_updated_(false),
       text_direction_(blink::WebTextDirectionLeftToRight),
@@ skipping 386 matching lines @@
   // does nothing if the sizes are already in sync.
   //
   // TODO: ideally ViewMsg_WasShown would take a size. This way, the renderer
   // could handle both the restore and resize at once. This isn't that big a
   // deal as RenderWidget::WasShown delays updating, so that the resize from
   // WasResized is usually processed before the renderer is painted.
   WasResized();
 }
 
 bool RenderWidgetHostImpl::GetResizeParams(
-    ViewMsg_Resize_Params* resize_params) const {
-  DCHECK(!screen_info_out_of_date_);
-
+    ViewMsg_Resize_Params* resize_params) {
   *resize_params = ViewMsg_Resize_Params();
 
+  if (!screen_info_) {
+    screen_info_.reset(new blink::WebScreenInfo);
+    GetWebScreenInfo(screen_info_.get());
+  }
   resize_params->screen_info = *screen_info_;
   resize_params->resizer_rect = GetRootWindowResizerRect();
 
   if (view_) {
     resize_params->new_size = view_->GetRequestedRendererSize();
     resize_params->physical_backing_size = view_->GetPhysicalBackingSize();
     resize_params->top_controls_height = view_->GetTopControlsHeight();
     resize_params->top_controls_shrink_blink_size =
         view_->DoTopControlsShrinkBlinkSize();
     resize_params->visible_viewport_size = view_->GetVisibleViewportSize();
     resize_params->is_fullscreen_granted = IsFullscreenGranted();
   }
 
   const bool size_changed =
       !old_resize_params_ ||
       old_resize_params_->new_size != resize_params->new_size ||
       (old_resize_params_->physical_backing_size.IsEmpty() &&
        !resize_params->physical_backing_size.IsEmpty());
   bool dirty =
-      size_changed ||
+      size_changed || screen_info_out_of_date_ ||
       old_resize_params_->physical_backing_size !=
           resize_params->physical_backing_size ||
       old_resize_params_->is_fullscreen_granted !=
           resize_params->is_fullscreen_granted ||
       old_resize_params_->top_controls_height !=
           resize_params->top_controls_height ||
       old_resize_params_->top_controls_shrink_blink_size !=
           resize_params->top_controls_shrink_blink_size ||
       old_resize_params_->visible_viewport_size !=
           resize_params->visible_viewport_size;
 
   // We don't expect to receive an ACK when the requested size or the physical
   // backing size is empty, or when the main viewport size didn't change.
   resize_params->needs_resize_ack =
       g_check_for_pending_resize_ack && !resize_params->new_size.IsEmpty() &&
       !resize_params->physical_backing_size.IsEmpty() && size_changed;
 
   return dirty;
 }
 
-bool RenderWidgetHostImpl::UpdateScreenInfo() {
-  if (!screen_info_out_of_date_)
-    return false;
-
-  screen_info_.reset(new blink::WebScreenInfo);
-  GetWebScreenInfo(screen_info_.get());
-  screen_info_out_of_date_ = false;
-
-  return true;
-}
-
 void RenderWidgetHostImpl::SetInitialRenderSizeParams(
     const ViewMsg_Resize_Params& resize_params) {
   resize_ack_pending_ = resize_params.needs_resize_ack;
 
   old_resize_params_ =
       make_scoped_ptr(new ViewMsg_Resize_Params(resize_params));
 }
 
 void RenderWidgetHostImpl::WasResized() {
   // Skip if the |delegate_| has already been detached because
   // it's web contents is being deleted.
   if (resize_ack_pending_ || !process_->HasConnection() || !view_ ||
       !renderer_initialized_ || auto_resize_enabled_ || !delegate_) {
     return;
   }
 
-  bool screen_info_was_updated = UpdateScreenInfo();
   scoped_ptr<ViewMsg_Resize_Params> params(new ViewMsg_Resize_Params);
-  if (!GetResizeParams(params.get()) && !screen_info_was_updated)
+  if (!GetResizeParams(params.get()))
     return;
 
   bool width_changed =
       !old_resize_params_ ||
       old_resize_params_->new_size.width() != params->new_size.width();
   if (Send(new ViewMsg_Resize(routing_id_, *params))) {
     resize_ack_pending_ = params->needs_resize_ack;
     old_resize_params_.swap(params);
   }
 
@@ skipping 473 matching lines @@
     }
   }
 }
 
 void RenderWidgetHostImpl::GetWebScreenInfo(blink::WebScreenInfo* result) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::GetWebScreenInfo");
   if (view_)
     view_->GetScreenInfo(result);
   else
     RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
-  // TODO(sievers): find a way to make this done another way so the method
-  // can be const.
   latency_tracker_.set_device_scale_factor(result->deviceScaleFactor);
+  screen_info_out_of_date_ = false;
 }
 
 const NativeWebKeyboardEvent*
     RenderWidgetHostImpl::GetLastKeyboardEvent() const {
   return input_router_->GetLastKeyboardEvent();
 }
 
 void RenderWidgetHostImpl::NotifyScreenInfoChanged() {
   if (delegate_)
     delegate_->ScreenInfoChanged();
@@ skipping 970 matching lines @@
 }
 #endif
 
 SkColorType RenderWidgetHostImpl::PreferredReadbackFormat() {
   if (view_)
     return view_->PreferredReadbackFormat();
   return kN32_SkColorType;
 }
 
 }  // namespace content