[cc] Enable specifying a overhang/gutter texture.

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/containers/hash_tables.h"
@@ skipping 20 matching lines @@
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/render_surface_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 136 matching lines @@
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
       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),
+      overhang_ui_resource_id_(0),
       overdraw_bottom_height_(0.f),
       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);
 
@@ skipping 311 matching lines @@
   if (layer->has_replica()) {
     is_replica = true;
     layer->render_surface()->AppendQuads(&quad_culler,
                                          append_quads_data,
                                          is_replica,
                                          contributing_render_pass->id);
   }
 }
 
 static void AppendQuadsToFillScreen(
+    ResourceProvider::ResourceId resource_id,
+    gfx::Size resource_size,
     RenderPass* target_render_pass,
     LayerImpl* root_layer,
     SkColor screen_background_color,
     const OcclusionTrackerImpl& occlusion_tracker) {
   if (!root_layer || !SkColorGetA(screen_background_color))
     return;
 
   Region fill_region = occlusion_tracker.ComputeVisibleRegionInScreen();
   if (fill_region.IsEmpty())
     return;
@@ skipping 28 matching lines @@
   bool did_invert = root_layer->screen_space_transform().GetInverse(
       &transform_to_layer_space);
   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 (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,
+          resource_id,
+          false,
+          gfx::PointF(
+              layer_rect.x() / static_cast<float>(resource_size.width()),

[enne (OOO), 2013/09/03 23:18:26]

Does this also need to have a device scale conversion? layer_rect here is in
device space, so the linen texture will be 1:1 with device pixels.

[ccameron, 2013/09/04 02:36:47]

YES!! I just discovered this as your email was coming in. 

+              layer_rect.y() / static_cast<float>(resource_size.height())),
+          gfx::PointF(
+              (layer_rect.x() + layer_rect.width()) /

[enne (OOO), 2013/09/03 23:18:26]

style nit: layer_rect.right() and layer_rect.bottom()

[ccameron, 2013/09/04 02:36:47]

Done.

+                  static_cast<float>(resource_size.width()),
+              (layer_rect.y() + layer_rect.height()) /
+                  static_cast<float>(resource_size.height())),
+          screen_background_color,
+          vertex_opacity,
+          false);
+        quad_culler.Append(tex_quad.PassAs<DrawQuad>(), &append_quads_data);
+    } else {
+      // 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);
+    }
   }
 }
 
 bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   DCHECK(frame->render_passes.empty());
 
   if (!CanDraw() || !active_tree_->root_layer())
     return false;
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
@@ skipping 191 matching lines @@
     for (size_t j = 0; j < frame->render_passes[i]->quad_list.size(); ++j)
       DCHECK(frame->render_passes[i]->quad_list[j]->shared_quad_state);
     DCHECK(frame->render_passes_by_id.find(frame->render_passes[i]->id)
            != 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(),
+    AppendQuadsToFillScreen(ResourceIdForUIResource(overhang_ui_resource_id_),
+                            overhang_ui_resource_size_,
+                            frame->render_passes.back(),
                             active_tree_->root_layer(),
                             active_tree_->background_color(),
                             occlusion_tracker);
   }
 
   if (draw_frame)
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
   else
     DCHECK(!have_copy_request);
 
@@ skipping 982 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_ui_resource_size) {
+  overhang_ui_resource_id_ = overhang_ui_resource_id;
+  overhang_ui_resource_size_ = overhang_ui_resource_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 772 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