Update the nine patch layer to use UI resources

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <map>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
+#include "cc/resources/scoped_ui_resource.h"
+#include "cc/resources/ui_resource_bitmap.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/public/browser/android/compositor_client.h"
 #include "content/public/common/content_switches.h"
@@ skipping 185 matching lines @@
     ANativeWindow_release(window);
     {
       base::AutoLock lock(g_surface_map_lock.Get());
       g_surface_map.Get().insert(std::make_pair(surface_id_, j_surface));
     }
   }
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   if (!visible) {
+    for(UIResourceMap::iterator iter = ui_resource_map_.begin();
+        iter != ui_resource_map_.end();
+        iter++) {
+      scoped_ptr<cc::ScopedUIResource> resource(iter->second);
+    }
+    ui_resource_map_.clear();
     host_.reset();
   } else if (!host_) {
     cc::LayerTreeSettings settings;
     settings.compositor_name = "BrowserCompositor";
     settings.refresh_rate = 60.0;
     settings.impl_side_painting = false;
     settings.allow_antialiasing = false;
     settings.calculate_top_controls_position = false;
     settings.top_controls_height = 0.f;
     settings.use_memory_management = false;
     settings.highp_threshold_min = 2048;
 
     // Do not clear the framebuffer when rendering into external GL contexts
     // like Android View System's.
     if (UsesDirectGL())
       settings.should_clear_root_render_pass = false;
 
     scoped_refptr<base::SingleThreadTaskRunner> impl_thread_task_runner =
         g_impl_thread ? g_impl_thread->message_loop()->message_loop_proxy()
                       : NULL;
 
     host_ = cc::LayerTreeHost::Create(this, settings, impl_thread_task_runner);
     host_->SetRootLayer(root_layer_);
 
     host_->SetVisible(true);
     host_->SetLayerTreeHostClientReady();
     host_->SetViewportSize(size_);
     host_->set_has_transparent_background(has_transparent_background_);
+    // Need to recreate the UI resources because a new LTH has been created.
+    client_->DidLoseUIResources();
   }
 }
 
 void CompositorImpl::setDeviceScaleFactor(float factor) {
   if (host_)
     host_->SetDeviceScaleFactor(factor);
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
@@ skipping 11 matching lines @@
     host_->set_has_transparent_background(flag);
 }
 
 bool CompositorImpl::CompositeAndReadback(void *pixels, const gfx::Rect& rect) {
   if (host_)
     return host_->CompositeAndReadback(pixels, rect);
   else
     return false;
 }
 
+cc::UIResourceId CompositorImpl::GenerateUIResource(gfx::JavaBitmap& bitmap) {
+  if (!host_)
+    return 0;
+
+  void* src_pixels = bitmap.pixels();
+  gfx::Size size = bitmap.size();
+  uint8_t* dst_pixels = new uint8_t[size.GetArea() * 4];
+  memcpy(dst_pixels, src_pixels, size.GetArea() * 4);
+  scoped_ptr<cc::ScopedUIResource> ui_resource = cc::ScopedUIResource::Create(
+      host_.get(),
+      cc::UIResourceBitmap::Create(
+          dst_pixels, cc::UIResourceBitmap::RGBA8, size));
+  cc::UIResourceId id = ui_resource->id();
+  ui_resource_map_[id] = ui_resource.release();
+  return id;
+}
+
+void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) {
+  UIResourceMap::iterator iter = ui_resource_map_.find(resource_id);
+  if (iter != ui_resource_map_.end()) {
+    scoped_ptr<cc::ScopedUIResource> resource(iter->second);
+    ui_resource_map_.erase(resource_id);
+  }
+}
+
 WebKit::WebGLId CompositorImpl::GenerateTexture(gfx::JavaBitmap& bitmap) {
   unsigned int texture_id = BuildBasicTexture();
   WebKit::WebGraphicsContext3D* context =
       ImageTransportFactoryAndroid::GetInstance()->GetContext3D();
   if (texture_id == 0 || context->isContextLost() ||
       !context->makeContextCurrent())
     return 0;
   WebKit::WebGLId format = GetGLFormatForBitmap(bitmap);
   WebKit::WebGLId type = GetGLTypeForBitmap(bitmap);
 
@@ skipping 198 matching lines @@
     case ANDROID_BITMAP_FORMAT_RGBA_8888:
       return GL_UNSIGNED_BYTE;
       break;
     case ANDROID_BITMAP_FORMAT_RGB_565:
     default:
       return GL_UNSIGNED_SHORT_5_6_5;
   }
 }
 
 } // namespace content