Revert 223162 "Update the nine patch layer to use UI resources"

trunk/src/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 43 matching lines @@
       allow_partial_texture_updates(false),
       using_offscreen_context3d(false),
       max_texture_size(0),
       avoid_pow2_textures(false),
       using_map_image(false),
       using_shared_memory_resources(false),
       using_discard_framebuffer(false) {}
 
 RendererCapabilities::~RendererCapabilities() {}
 
-UIResourceRequest::UIResourceRequest(UIResourceRequestType type,
-                                     UIResourceId id)
-    : type_(type), id_(id) {}
-
-UIResourceRequest::UIResourceRequest(UIResourceRequestType type,
-                                     UIResourceId id,
-                                     const UIResourceBitmap& bitmap)
-    : type_(type), id_(id), bitmap_(new UIResourceBitmap(bitmap)) {}
-
-UIResourceRequest::UIResourceRequest(const UIResourceRequest& request) {
-  (*this) = request;
-}
-
-UIResourceRequest& UIResourceRequest::operator=(
-    const UIResourceRequest& request) {
-  type_ = request.type_;
-  id_ = request.id_;
-  if (request.bitmap_) {
-    bitmap_ = make_scoped_ptr(new UIResourceBitmap(*request.bitmap_.get()));
-  } else {
-    bitmap_.reset();
-  }
-
-  return *this;
-}
+UIResourceRequest::UIResourceRequest()
+    : type(UIResourceInvalidRequest), id(0), bitmap(NULL) {}
 
 UIResourceRequest::~UIResourceRequest() {}
 
 bool LayerTreeHost::AnyLayerTreeHostInstanceExists() {
   return s_num_layer_tree_instances > 0;
 }
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::Create(
     LayerTreeHostClient* client,
     const LayerTreeSettings& settings,
@@ skipping 293 matching lines @@
     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_) {
     host_impl->SetOverhangUIResource(
         overhang_ui_resource_->id(),
-        GetUIResourceSize(overhang_ui_resource_->id()));
+        overhang_ui_resource_->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) {
@@ skipping 237 matching lines @@
   page_scale_factor_ = page_scale_factor;
   min_page_scale_factor_ = min_page_scale_factor;
   max_page_scale_factor_ = max_page_scale_factor;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetOverhangBitmap(const SkBitmap& bitmap) {
   DCHECK(bitmap.width() && bitmap.height());
   DCHECK_EQ(bitmap.bytesPerPixel(), 4);
 
-  SkBitmap bitmap_copy;
-  if (bitmap.isImmutable()) {
-    bitmap_copy = bitmap;
-  } else {
-    bitmap.copyTo(&bitmap_copy, bitmap.config());
-    bitmap_copy.setImmutable();
-  }
-
-  overhang_ui_resource_ = ScopedUIResource::Create(
-      this, UIResourceBitmap(bitmap_copy, UIResourceBitmap::REPEAT));
+  scoped_refptr<UIResourceBitmap> overhang_ui_bitmap(UIResourceBitmap::Create(
+      new uint8_t[bitmap.width() * bitmap.height() * bitmap.bytesPerPixel()],
+      UIResourceBitmap::RGBA8,
+      UIResourceBitmap::REPEAT,
+      gfx::Size(bitmap.width(), bitmap.height())));
+  bitmap.copyPixelsTo(
+      overhang_ui_bitmap->GetPixels(),
+      bitmap.width() * bitmap.height() * bitmap.bytesPerPixel(),
+      bitmap.width() * bitmap.bytesPerPixel());
+  overhang_ui_resource_ = ScopedUIResource::Create(this, overhang_ui_bitmap);
 }
 
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
   if (!visible)
     ReduceMemoryUsage();
   proxy_->SetVisible(visible);
 }
@@ skipping 482 matching lines @@
        ++iter) {
     (*iter).second->Animate(monotonic_time);
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
 }
 
 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
   DCHECK(client);
 
-  UIResourceId next_id = next_ui_resource_id_++;
-  DCHECK(ui_resource_client_map_.find(next_id) ==
+  UIResourceRequest request;
+  bool resource_lost = false;
+  request.type = UIResourceRequest::UIResourceCreate;
+  request.id = next_ui_resource_id_++;
+
+  DCHECK(ui_resource_client_map_.find(request.id) ==
          ui_resource_client_map_.end());
 
-  bool resource_lost = false;
-  UIResourceRequest request(UIResourceRequest::UIResourceCreate,
-                            next_id,
-                            client->GetBitmap(next_id, resource_lost));
+  request.bitmap = client->GetBitmap(request.id, resource_lost);
   ui_resource_request_queue_.push_back(request);
-
-  UIResourceClientData data;
-  data.client = client;
-  data.size = request.GetBitmap().GetSize();
-
-  ui_resource_client_map_[request.GetId()] = data;
-  return request.GetId();
+  ui_resource_client_map_[request.id] = client;
+  return request.id;
 }
 
 // Deletes a UI resource.  May safely be called more than once.
 void LayerTreeHost::DeleteUIResource(UIResourceId uid) {
   UIResourceClientMap::iterator iter = ui_resource_client_map_.find(uid);
   if (iter == ui_resource_client_map_.end())
     return;
 
-  UIResourceRequest request(UIResourceRequest::UIResourceDelete, uid);
+  UIResourceRequest request;
+  request.type = UIResourceRequest::UIResourceDelete;
+  request.id = uid;
   ui_resource_request_queue_.push_back(request);
-  ui_resource_client_map_.erase(iter);
+  ui_resource_client_map_.erase(uid);
 }
 
 void LayerTreeHost::RecreateUIResources() {
   for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
        iter != ui_resource_client_map_.end();
        ++iter) {
     UIResourceId uid = iter->first;
-    const UIResourceClientData& data = iter->second;
+    UIResourceRequest request;
+    request.type = UIResourceRequest::UIResourceCreate;
+    request.id = uid;
     bool resource_lost = true;
-    UIResourceRequest request(UIResourceRequest::UIResourceCreate,
-                              uid,
-                              data.client->GetBitmap(uid, resource_lost));
+    request.bitmap = iter->second->GetBitmap(uid, resource_lost);
+    DCHECK(request.bitmap.get());
     ui_resource_request_queue_.push_back(request);
   }
 }
 
-// Returns the size of a resource given its id.
-gfx::Size LayerTreeHost::GetUIResourceSize(UIResourceId uid) const {
-  UIResourceClientMap::const_iterator iter = ui_resource_client_map_.find(uid);
-  if (iter == ui_resource_client_map_.end())
-    return gfx::Size();
-
-  const UIResourceClientData& data = iter->second;
-  return data.size;
-}
-
 }  // namespace cc