(not for review) Add overhang resource

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 19 matching lines @@
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/delegating_renderer.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/software_renderer.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/picture_layer_tiling.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/texture_uploader.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
@@ skipping 140 matching lines @@
       paint_time_counter_(PaintTimeCounter::Create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       max_memory_needed_bytes_(0),
       last_sent_memory_visible_bytes_(0),
       last_sent_memory_visible_and_nearby_bytes_(0),
       last_sent_memory_use_bytes_(0),
       zero_budget_(false),
       device_scale_factor_(1.f),
       overdraw_bottom_height_(0.f),
+      overhang_ui_resource_id_(0),
+      overhang_image_size_(0, 0),
       external_stencil_test_enabled_(false),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       need_to_update_visible_tiles_before_draw_(false) {
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initial_debug_state);
 
   if (settings.calculate_top_controls_position) {
@@ skipping 286 matching lines @@
                                          append_quads_data,
                                          is_replica,
                                          contributing_render_pass->id);
   }
 }
 
 static void AppendQuadsToFillScreen(
     RenderPass* target_render_pass,
     LayerImpl* root_layer,
     SkColor screen_background_color,
-    const OcclusionTrackerImpl& occlusion_tracker) {
+    const OcclusionTrackerImpl& occlusion_tracker,
+    ResourceProvider::ResourceId overhang_resource_id,
+    gfx::Size overhang_image_size) {
   if (!root_layer || !SkColorGetA(screen_background_color))
     return;
 
   Region fill_region = occlusion_tracker.ComputeVisibleRegionInScreen();
   if (fill_region.IsEmpty())
     return;
 
   bool for_surface = false;
   QuadCuller quad_culler(&target_render_pass->quad_list,
                          &target_render_pass->shared_quad_state_list,
@@ skipping 26 matching lines @@
   DCHECK(did_invert);
   for (Region::Iterator fill_rects(fill_region);
        fill_rects.has_rect();
        fill_rects.next()) {
     // The root layer transform is composed of translations and scales only,
     // no perspective, so mapping is sufficient (as opposed to projecting).
     gfx::Rect layer_rect =
         MathUtil::MapClippedRect(transform_to_layer_space, fill_rects.rect());
     // Skip the quad culler and just append the quads directly to avoid
     // occlusion checks.
-    scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-    quad->SetNew(shared_quad_state, layer_rect, screen_background_color, false);
-    quad_culler.Append(quad.PassAs<DrawQuad>(), &append_quads_data);
+    if (overhang_resource_id) {
+      scoped_ptr<TextureDrawQuad> tex_quad = TextureDrawQuad::Create();
+      const float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
+      tex_quad->SetNew(
+          shared_quad_state,
+          layer_rect,
+          layer_rect,
+          overhang_resource_id,
+          false,
+          gfx::PointF(
+              layer_rect.x() /
+                static_cast<float>(overhang_image_size.width()),
+              layer_rect.y() /
+                  static_cast<float>(overhang_image_size.height())),
+          gfx::PointF(
+              (layer_rect.x() + layer_rect.width()) /
+                static_cast<float>(overhang_image_size.width()),
+              (layer_rect.y() + layer_rect.height()) /
+                  static_cast<float>(overhang_image_size.height())),
+          screen_background_color,
+          vertex_opacity,
+          false);
+      quad_culler.Append(tex_quad.PassAs<DrawQuad>(), &append_quads_data);
+    } else {
+      scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+      quad->SetNew(
+          shared_quad_state, layer_rect, screen_background_color, false);
+      quad_culler.Append(quad.PassAs<DrawQuad>(), &append_quads_data);
+    }
   }
 }
 
 bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   DCHECK(frame->render_passes.empty());
 
   if (!CanDraw() || !active_tree_->root_layer())
     return false;
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
@@ skipping 194 matching lines @@
            != frame->render_passes_by_id.end());
   }
 #endif
   DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 
   if (!active_tree_->has_transparent_background()) {
     frame->render_passes.back()->has_transparent_background = false;
     AppendQuadsToFillScreen(frame->render_passes.back(),
                             active_tree_->root_layer(),
                             active_tree_->background_color(),
-                            occlusion_tracker);
+                            occlusion_tracker,
+                            ResourceIdForUIResource(overhang_ui_resource_id_),
+                            overhang_image_size_);
   }
 
   if (draw_frame)
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
   else
     DCHECK(!have_copy_request);
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
   if (!output_surface_->ForcedDrawToSoftwareDevice())
     renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
@@ skipping 950 matching lines @@
 
 void LayerTreeHostImpl::SetOverdrawBottomHeight(float overdraw_bottom_height) {
   if (overdraw_bottom_height == overdraw_bottom_height_)
     return;
   overdraw_bottom_height_ = overdraw_bottom_height;
 
   UpdateMaxScrollOffset();
   SetFullRootLayerDamage();
 }
 
+void LayerTreeHostImpl::SetOverhangUIResource(
+    UIResourceId overhang_ui_resource_id, gfx::Size overhang_image_size) {
+  overhang_ui_resource_id_ = overhang_ui_resource_id;
+  overhang_image_size_ = overhang_image_size;
+}
+
 void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor == device_scale_factor_)
     return;
   device_scale_factor_ = device_scale_factor;
 
   if (renderer_)
     renderer_->ViewportChanged();
 
   UpdateMaxScrollOffset();
   SetFullRootLayerDamage();
@@ skipping 763 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc