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 21 matching lines @@
     sync_tree->DidBecomeActive();
   }
 
   commit_number_++;
 }
 
 void LayerTreeHost::SetPinchZoomScrollbarsBoundsAndPosition() {
   if (!pinch_zoom_scrollbar_horizontal_ || !pinch_zoom_scrollbar_vertical_)
     return;
 
-  gfx::Size size = layout_viewport_size();
+  gfx::Size size = gfx::ToCeiledSize(
+      gfx::ScaleSize(device_viewport_size(), 1 / device_scale_factor()));

[danakj, 2013/04/09 00:04:35]

nit: 1.f

   int track_width = PinchZoomScrollbarGeometry::kTrackWidth;
 
   pinch_zoom_scrollbar_horizontal_->SetBounds(
       gfx::Size(size.width() - track_width, track_width));
   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));
   pinch_zoom_scrollbar_vertical_->SetPosition(
@@ skipping 218 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