Delete layout_viewport_size.

cc/trees/layer_tree_host.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 19 matching lines @@
 #include "cc/layers/scrollbar_layer.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
+#include "ui/gfx/size_conversions.h"
 
 namespace {
 static int s_num_layer_tree_instances;
 }
 
 namespace cc {
 
 RendererCapabilities::RendererCapabilities()
     : best_texture_format(0),
       using_partial_swap(false),
@@ skipping 285 matching lines @@
     page_scale_delta = sync_tree->page_scale_delta();
     sent_page_scale_delta = sync_tree->sent_page_scale_delta();
     sync_tree->set_sent_page_scale_delta(1.f);
   }
 
   sync_tree->SetPageScaleFactorAndLimits(page_scale_factor_,
                                          min_page_scale_factor_,
                                          max_page_scale_factor_);
   sync_tree->SetPageScaleDelta(page_scale_delta / sent_page_scale_delta);
 
-  host_impl->SetViewportSize(layout_viewport_size_, device_viewport_size_);
+  host_impl->SetViewportSize(device_viewport_size_);
   host_impl->SetOverdrawBottomHeight(overdraw_bottom_height_);
   host_impl->SetDeviceScaleFactor(device_scale_factor_);
   host_impl->SetDebugState(debug_state_);
   if (pending_page_scale_animation_) {
     host_impl->StartPageScaleAnimation(
         pending_page_scale_animation_->target_offset,
         pending_page_scale_animation_->use_anchor,
         pending_page_scale_animation_->scale,
         base::TimeTicks::Now(),
         pending_page_scale_animation_->duration);
@@ skipping 17 matching lines @@
 
   if (!settings_.impl_side_painting) {
     // If we're not in impl-side painting, the tree is immediately
     // considered active.
     sync_tree->DidBecomeActive();
   }
 
   commit_number_++;
 }
 
+gfx::Size LayerTreeHost::PinchZoomScrollbarSize(
+    WebKit::WebScrollbar::Orientation orientation) const {
+  gfx::Size viewport_size = gfx::ToCeiledSize(
+      gfx::ScaleSize(device_viewport_size(), 1.f / device_scale_factor()));
+  gfx::Size size;
+  int track_width = PinchZoomScrollbarGeometry::kTrackWidth;
+  if (orientation == WebKit::WebScrollbar::Horizontal)
+    size = gfx::Size(viewport_size.width() - track_width, track_width);
+  else
+    size = gfx::Size(track_width, viewport_size.height() - track_width);
+  return size;
+}
+
 void LayerTreeHost::SetPinchZoomScrollbarsBoundsAndPosition() {
   if (!pinch_zoom_scrollbar_horizontal_ || !pinch_zoom_scrollbar_vertical_)
     return;
 
-  gfx::Size size = layout_viewport_size();
-  int track_width = PinchZoomScrollbarGeometry::kTrackWidth;
+  gfx::Size horizontal_size =
+      PinchZoomScrollbarSize(WebKit::WebScrollbar::Horizontal);
+  gfx::Size vertical_size =
+      PinchZoomScrollbarSize(WebKit::WebScrollbar::Vertical);
 
-  pinch_zoom_scrollbar_horizontal_->SetBounds(
-      gfx::Size(size.width() - track_width, track_width));
+  pinch_zoom_scrollbar_horizontal_->SetBounds(horizontal_size);
   pinch_zoom_scrollbar_horizontal_->SetPosition(
-      gfx::PointF(0, size.height() - track_width));
-
-  pinch_zoom_scrollbar_vertical_->SetBounds(
-      gfx::Size(track_width, size.height() - track_width));
+      gfx::PointF(0, vertical_size.height()));
+  pinch_zoom_scrollbar_vertical_->SetBounds(vertical_size);
   pinch_zoom_scrollbar_vertical_->SetPosition(
-      gfx::PointF(size.width() - track_width, 0));
+      gfx::PointF(horizontal_size.width(), 0));
 }
 
 static scoped_refptr<ScrollbarLayer> CreatePinchZoomScrollbar(
     WebKit::WebScrollbar::Orientation orientation,
     LayerTreeHost* owner) {
   scoped_refptr<ScrollbarLayer> scrollbar_layer = ScrollbarLayer::Create(
       make_scoped_ptr(new PinchZoomScrollbar(orientation, owner)).
           PassAs<WebKit::WebScrollbar>(),
       scoped_ptr<ScrollbarThemePainter>(new PinchZoomScrollbarPainter).Pass(),
       scoped_ptr<WebKit::WebScrollbarThemeGeometry>(
@@ skipping 207 matching lines @@
     return;
 
   debug_state_ = new_debug_state;
 
   rendering_stats_instrumentation_->set_record_rendering_stats(
       debug_state_.RecordRenderingStats());
 
   SetNeedsCommit();
 }
 
-void LayerTreeHost::SetViewportSize(gfx::Size layout_viewport_size,
-                                    gfx::Size device_viewport_size) {
-  if (layout_viewport_size == layout_viewport_size_ &&
-      device_viewport_size == device_viewport_size_)
+void LayerTreeHost::SetViewportSize(gfx::Size device_viewport_size) {
+  if (device_viewport_size == device_viewport_size_)
     return;
 
-  layout_viewport_size_ = layout_viewport_size;
   device_viewport_size_ = device_viewport_size;
 
   SetPinchZoomScrollbarsBoundsAndPosition();
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetOverdrawBottomHeight(float overdraw_bottom_height) {
   if (overdraw_bottom_height_ == overdraw_bottom_height)
     return;
 
@@ skipping 62 matching lines @@
   return true;
 }
 
 void LayerTreeHost::UpdateLayers(ResourceUpdateQueue* queue,
                                  size_t memory_allocation_limit_bytes) {
   DCHECK(renderer_initialized_);
 
   if (!root_layer())
     return;
 
-  if (layout_viewport_size().IsEmpty())
+  if (device_viewport_size().IsEmpty())
     return;
 
   if (memory_allocation_limit_bytes) {
     contents_texture_manager_->SetMaxMemoryLimitBytes(
         memory_allocation_limit_bytes);
   }
 
   UpdateLayers(root_layer(), queue);
 }
 
@@ skipping 344 matching lines @@
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc