Migrate the Android compositor to cc::Layer classes.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "cc/font_atlas.h"
+#include "cc/input_handler.h"
+#include "cc/layer.h"
+#include "cc/layer_tree_host.h"
+#include "cc/thread_impl.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/image_transport_factory_android.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/common/content_switches.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebCompositorOutputSurface.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebSolidColorLayer.h"
 #include "ui/gfx/android/java_bitmap.h"
-#include "webkit/compositor_bindings/web_compositor_support_impl.h"
 #include "webkit/glue/webthread_impl.h"
 #include "webkit/gpu/webgraphicscontext3d_in_process_impl.h"
 
-using webkit::WebCompositorSupportImpl;
-
 namespace gfx {
 class JavaBitmap;
 }
 
 namespace {
 
 static bool g_initialized = false;
-static base::LazyInstance<WebCompositorSupportImpl> g_compositor_support =
-    LAZY_INSTANCE_INITIALIZER;
-static WebKit::WebThread* g_impl_thread = NULL;
+static webkit_glue::WebThreadImpl* g_impl_thread = NULL;
 static bool g_use_direct_gl = false;
 
 // Adapts a pure WebGraphicsContext3D into a WebCompositorOutputSurface.
 class WebGraphicsContextToOutputSurfaceAdapter :
     public WebKit::WebCompositorOutputSurface {
 public:
     explicit WebGraphicsContextToOutputSurfaceAdapter(
         WebKit::WebGraphicsContext3D* context)
         : m_context3D(context)
         , m_client(0)
@@ skipping 36 matching lines @@
 namespace content {
 
 // static
 Compositor* Compositor::Create(Client* client) {
   return client ? new CompositorImpl(client) : NULL;
 }
 
 // static
 void Compositor::Initialize() {
   DCHECK(!CompositorImpl::IsInitialized());
-  g_compositor_support.Get().initialize(g_impl_thread);
   g_initialized = true;
 }
 
 // static
 void Compositor::InitializeWithFlags(uint32 flags) {
   g_use_direct_gl = flags & DIRECT_CONTEXT_ON_DRAW_THREAD;
-  if (flags & ENABLE_COMPOSITOR_THREAD)
+  if (flags & ENABLE_COMPOSITOR_THREAD) {
+    TRACE_EVENT_INSTANT0("test_gpu", "ThreadedCompositingInitialization");
     g_impl_thread = new webkit_glue::WebThreadImpl("Browser Compositor");
+  }
   Compositor::Initialize();
 }
 
 // static
-WebCompositorSupportImpl* CompositorImpl::CompositorSupport() {
-  DCHECK(g_initialized);
-  return g_compositor_support.Pointer();
-}
-
-// static
 bool CompositorImpl::IsInitialized() {
   return g_initialized;
 }
 
 // static
+bool CompositorImpl::IsThreadingEnabled() {
+  return g_impl_thread;
+}
+
+// static
 bool CompositorImpl::UsesDirectGL() {
   return g_use_direct_gl;
 }
 
 CompositorImpl::CompositorImpl(Compositor::Client* client)
-    : window_(NULL),
+    : root_layer_(cc::Layer::create()),
+      window_(NULL),
       surface_id_(0),
       client_(client),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(client);
-  root_layer_.reset(g_compositor_support.Get().createLayer());
 }
 
 CompositorImpl::~CompositorImpl() {
 }
 
 void CompositorImpl::Composite() {
   if (host_.get())
     host_->composite();
 }
 
-void CompositorImpl::SetRootLayer(WebKit::WebLayer* root_layer) {
+void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
   root_layer_->removeAllChildren();
   root_layer_->addChild(root_layer);
 }
 
 void CompositorImpl::SetWindowSurface(ANativeWindow* window) {
   GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
 
   if (window_) {
     tracker->RemoveSurface(surface_id_);
     ANativeWindow_release(window_);
@@ skipping 10 matching lines @@
         surface_id_,
         gfx::GLSurfaceHandle(gfx::kDummyPluginWindow, false));
     SetVisible(true);
   }
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   if (!visible) {
     host_.reset();
   } else if (!host_.get()) {
-    WebKit::WebLayerTreeView::Settings settings;
+    cc::LayerTreeSettings settings;
     settings.refreshRate = 60.0;
-    host_.reset(g_compositor_support.Get().createLayerTreeView(
-        this, *root_layer_, settings));
+
+    scoped_ptr<cc::Thread> impl_thread;
+    if (g_impl_thread)
+      impl_thread = cc::ThreadImpl::createForDifferentThread(
+          g_impl_thread->message_loop()->message_loop_proxy());
+
+    host_ = cc::LayerTreeHost::create(this, settings, impl_thread.Pass());
+    host_->setRootLayer(root_layer_);
+
     host_->setVisible(true);
     host_->setSurfaceReady();
-    host_->setViewportSize(size_);
+    host_->setViewportSize(size_, size_);
   }
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
     return;
 
   size_ = size;
   if (host_)
-    host_->setViewportSize(size);
+    host_->setViewportSize(size, size);
   root_layer_->setBounds(size);
 }
 
 bool CompositorImpl::CompositeAndReadback(void *pixels, const gfx::Rect& rect) {
   if (host_.get())
     return host_->compositeAndReadback(pixels, rect);
   else
     return false;
 }
 
@@ skipping 52 matching lines @@
 }
 
 void CompositorImpl::CopyTextureToBitmap(WebKit::WebGLId texture_id,
                                          gfx::JavaBitmap& bitmap) {
   GLHelper* helper = ImageTransportFactoryAndroid::GetInstance()->GetGLHelper();
   helper->ReadbackTextureSync(texture_id,
                               bitmap.size(),
                               static_cast<unsigned char*> (bitmap.pixels()));
 }
 
-void CompositorImpl::updateAnimations(double frameBeginTime) {
+void CompositorImpl::animate(double monotonicFrameBeginTime) {
 }
 
 void CompositorImpl::layout() {
 }
 
-void CompositorImpl::applyScrollAndScale(const WebKit::WebSize& scrollDelta,
-                                     float scaleFactor) {
+void CompositorImpl::applyScrollAndScale(gfx::Vector2d scrollDelta,
+                                         float pageScale) {
 }
 
-WebKit::WebCompositorOutputSurface* CompositorImpl::createOutputSurface() {
+scoped_ptr<WebKit::WebCompositorOutputSurface>
+    CompositorImpl::createOutputSurface() {
   if (g_use_direct_gl) {
     WebKit::WebGraphicsContext3D::Attributes attrs;
     attrs.shareResources = false;
     attrs.noAutomaticFlushes = true;
     scoped_ptr<webkit::gpu::WebGraphicsContext3DInProcessImpl> context(
         webkit::gpu::WebGraphicsContext3DInProcessImpl::CreateForWindow(
             attrs,
             window_,
             NULL));
-    return new WebGraphicsContextToOutputSurfaceAdapter(context.release());
+    return scoped_ptr<WebKit::WebCompositorOutputSurface>(
+        new WebGraphicsContextToOutputSurfaceAdapter(context.release()));
   } else {
     DCHECK(window_ && surface_id_);
     WebKit::WebGraphicsContext3D::Attributes attrs;
     attrs.shareResources = true;
     attrs.noAutomaticFlushes = true;
     GpuChannelHostFactory* factory = BrowserGpuChannelHostFactory::instance();
     GURL url("chrome://gpu/Compositor::createContext3D");
     scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
         new WebGraphicsContext3DCommandBufferImpl(surface_id_,
                                                   url,
                                                   factory,
                                                   weak_factory_.GetWeakPtr()));
     if (!context->Initialize(
         attrs,
         false,
         CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE)) {
       LOG(ERROR) << "Failed to create 3D context for compositor.";
-      return NULL;
+      return scoped_ptr<WebKit::WebCompositorOutputSurface>();
     }
-    return new WebGraphicsContextToOutputSurfaceAdapter(context.release());
+    return scoped_ptr<WebKit::WebCompositorOutputSurface>(
+        new WebGraphicsContextToOutputSurfaceAdapter(context.release()));
   }
 }
 
+scoped_ptr<cc::InputHandler> CompositorImpl::createInputHandler() {
+  return scoped_ptr<cc::InputHandler>();
+}
+
 void CompositorImpl::didRecreateOutputSurface(bool success) {
 }
 
 void CompositorImpl::didCommit() {
 }
 
 void CompositorImpl::didCommitAndDrawFrame() {
 }
 
 void CompositorImpl::didCompleteSwapBuffers() {
   client_->OnSwapBuffersCompleted();
 }
 
 void CompositorImpl::scheduleComposite() {
   client_->ScheduleComposite();
 }
 
+scoped_ptr<cc::FontAtlas> CompositorImpl::createFontAtlas() {
+  return scoped_ptr<cc::FontAtlas>();
+}
+
 void CompositorImpl::OnViewContextSwapBuffersPosted() {
   TRACE_EVENT0("compositor", "CompositorImpl::OnViewContextSwapBuffersPosted");
 }
 
 void CompositorImpl::OnViewContextSwapBuffersComplete() {
   TRACE_EVENT0("compositor",
                "CompositorImpl::OnViewContextSwapBuffersComplete");
   client_->OnSwapBuffersCompleted();
 }
 
@@ skipping 46 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