(not for review) Add overhang resource

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 <stack>
 
 #include "base/bind.h"
@@ skipping 20 matching lines @@
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/ui_resource_client.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/base/resource/resource_bundle.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace {
 static int s_num_layer_tree_instances;
 }
 
 namespace cc {
 
 RendererCapabilities::RendererCapabilities()
     : best_texture_format(0),
@@ skipping 138 matching lines @@
     settings_.max_partial_texture_updates = max_partial_texture_updates;
 
     if (!contents_texture_manager_ &&
         (!settings_.impl_side_painting || !settings_.solid_color_scrollbars)) {
       contents_texture_manager_ =
           PrioritizedResourceManager::Create(proxy_.get());
       surface_memory_placeholder_ =
           contents_texture_manager_->CreateTexture(gfx::Size(), GL_RGBA);
     }
 
+    // Okay, this should be done in a more principled way...
+    if (1) {
+      // So this is supposed to come from a header file (but only on platforms
+      // that have an overhang...).
+      int IDR_IDR_OVERHANG_PATTERN = 4740;
+      // And this can't be called in unit tests...
+      const gfx::Image& overhang_image =
+          ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+              IDR_IDR_OVERHANG_PATTERN);
+      overhang_bitmap_ = UIResourceBitmap::Create(
+          new uint8_t[overhang_image.Size().width() *
+                      overhang_image.Size().height() * 4],
+          UIResourceBitmap::RGBA8,
+          UIResourceBitmap::Repeat,
+          overhang_image.Size());
+      overhang_image.CopySkBitmap()->copyPixelsTo(
+          overhang_bitmap_->GetPixels(),
+          overhang_image.Size().width() * overhang_image.Size().height() * 4,
+          overhang_image.Size().width() * 4,
+          false);
+      overhang_ui_resource_ = ScopedUIResource::Create(this, overhang_bitmap_);
+    }
+
     client_->DidInitializeOutputSurface(true);
     return CreateSucceeded;
   }
 
   // Failure path.
 
   client_->DidFailToInitializeOutputSurface();
 
   // Tolerate a certain number of recreation failures to work around races
   // in the output-surface-lost machinery.
@@ skipping 153 matching lines @@
   }
 
   if (!ui_resource_request_queue_.empty()) {
     sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
     ui_resource_request_queue_.clear();
     // Process any ui resource requests in the queue.  For impl-side-painting,
     // the queue is processed in LayerTreeHostImpl::ActivatePendingTree.
     if (!settings_.impl_side_painting)
       sync_tree->ProcessUIResourceRequestQueue();
   }
+  if (overhang_ui_resource_ && overhang_bitmap_) {
+    host_impl->SetOverhangUIResource(
+        overhang_ui_resource_->id(), overhang_bitmap_->GetSize());
+  }
 
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   if (new_impl_tree_has_no_evicted_resources) {
     if (sync_tree->ContentsTexturesPurged())
       sync_tree->ResetContentsTexturesPurged();
   }
 
   if (!settings_.impl_side_painting) {
     // If we're not in impl-side painting, the tree is immediately
@@ skipping 790 matching lines @@
 void LayerTreeHost::DidLoseUIResources() {
   // When output surface is lost, we need to recreate the resource.
   for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
        iter != ui_resource_client_map_.end();
        ++iter) {
     UIResourceLost(iter->first);
   }
 }
 
 }  // namespace cc