ui/compositor: use cc/ directly instead of webkit

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
+#include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
+#include "cc/input_handler.h"
+#include "cc/layer.h"
+#include "cc/layer_tree_host.h"
+#include "cc/thread_impl.h"
 #include "third_party/skia/include/core/SkBitmap.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebCompositorSupport.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebFloatPoint.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebCompositorOutputSurface.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/test_web_graphics_context_3d.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
-#include "webkit/glue/webthread_impl.h"
 #include "webkit/gpu/webgraphicscontext3d_in_process_impl.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/chromeos/chromeos_version.h"
 #endif
 
 namespace {
 
 const double kDefaultRefreshRate = 60.0;
 const double kTestRefreshRate = 100.0;
 
 enum SwapType {
   DRAW_SWAP,
   READPIXELS_SWAP,
 };
 
-webkit_glue::WebThreadImpl* g_compositor_thread = NULL;
+base::Thread* g_compositor_thread = NULL;
 
 bool test_compositor_enabled = false;
 
 ui::ContextFactory* g_context_factory = NULL;
 
 const int kCompositorLockTimeoutMs = 67;
 
 // Adapts a pure WebGraphicsContext3D into a WebCompositorOutputSurface.
 class WebGraphicsContextToOutputSurfaceAdapter
     : public WebKit::WebCompositorOutputSurface {
@@ skipping 231 matching lines @@
                        gfx::AcceleratedWidget widget)
     : delegate_(delegate),
       root_layer_(NULL),
       widget_(widget),
       posted_swaps_(new PostedSwapQueue()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
       disable_schedule_composite_(false),
       compositor_lock_(NULL) {
-  WebKit::WebCompositorSupport* compositor_support =
-      WebKit::Platform::current()->compositorSupport();
-  root_web_layer_.reset(compositor_support->createLayer());
-  WebKit::WebLayerTreeView::Settings settings;
+  root_web_layer_ = cc::Layer::create();
+  root_web_layer_->setAnchorPoint(gfx::PointF(0.f, 0.f));
+
   CommandLine* command_line = CommandLine::ForCurrentProcess();
-  settings.showFPSCounter =
-      command_line->HasSwitch(switches::kUIShowFPSCounter);
+  cc::LayerTreeSettings settings;
   settings.showPlatformLayerTree =
       command_line->HasSwitch(switches::kUIShowLayerTree);
   settings.refreshRate =
       test_compositor_enabled ? kTestRefreshRate : kDefaultRefreshRate;
   settings.showDebugBorders =
       command_line->HasSwitch(switches::kUIShowLayerBorders);
   settings.partialSwapEnabled =
       command_line->HasSwitch(switches::kUIEnablePartialSwap);
   settings.perTilePaintingEnabled =
       command_line->HasSwitch(switches::kUIEnablePerTilePainting);
 
-  root_web_layer_->setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
-  host_.reset(compositor_support->createLayerTreeView(this, *root_web_layer_,
-                                                      settings));
+  scoped_ptr<cc::Thread> thread;
+  if (g_compositor_thread) {
+    thread = cc::ThreadImpl::createForDifferentThread(
+        g_compositor_thread->message_loop_proxy());
+  }
+
+  host_ = cc::LayerTreeHost::create(this, settings, thread.Pass());
+  host_->setShowFPSCounter(
+      command_line->HasSwitch(switches::kUIShowFPSCounter));
+  host_->setRootLayer(root_web_layer_);
   host_->setSurfaceReady();
 }
 
 Compositor::~Compositor() {
   CancelCompositorLock();
   DCHECK(!compositor_lock_);
 
   // Don't call |CompositorDelegate::ScheduleDraw| from this point.
   delegate_ = NULL;
   if (root_layer_)
     root_layer_->SetCompositor(NULL);
 
   // Stop all outstanding draws before telling the ContextFactory to tear
   // down any contexts that the |host_| may rely upon.
   host_.reset();
 
   if (!test_compositor_enabled)
     ContextFactory::GetInstance()->RemoveCompositor(this);
 }
 
 void Compositor::Initialize(bool use_thread) {
-  WebKit::WebCompositorSupport* compositor_support =
-      WebKit::Platform::current()->compositorSupport();
-  if (use_thread)
-    g_compositor_thread = new webkit_glue::WebThreadImpl("Browser Compositor");
-  compositor_support->initialize(g_compositor_thread);
+  if (use_thread) {
+    g_compositor_thread = new base::Thread("Browser Compositor");
+    g_compositor_thread->Start();
+  }
 }
 
 void Compositor::Terminate() {
-  WebKit::Platform::current()->compositorSupport()->shutdown();
   if (g_compositor_thread) {
+    g_compositor_thread->Stop();
     delete g_compositor_thread;
     g_compositor_thread = NULL;
   }
 }
 
 void Compositor::ScheduleDraw() {
   if (g_compositor_thread)
     host_->composite();
   else if (delegate_)
     delegate_->ScheduleDraw();
 }
 
 void Compositor::SetRootLayer(Layer* root_layer) {
   if (root_layer_ == root_layer)
     return;
   if (root_layer_)
     root_layer_->SetCompositor(NULL);
   root_layer_ = root_layer;
   if (root_layer_ && !root_layer_->GetCompositor())
     root_layer_->SetCompositor(this);
   root_web_layer_->removeAllChildren();
   if (root_layer_)
-    root_web_layer_->addChild(root_layer_->web_layer());
+    root_web_layer_->addChild(root_layer_->cc_layer());
 }
 
 void Compositor::SetHostHasTransparentBackground(
     bool host_has_transparent_background) {
   host_->setHasTransparentBackground(host_has_transparent_background);
 }
 
 void Compositor::Draw(bool force_clear) {
   DCHECK(!g_compositor_thread);
 
@@ skipping 29 matching lines @@
   CancelCompositorLock();
   PendingSwap pending_swap(READPIXELS_SWAP, posted_swaps_.get());
   return host_->compositeAndReadback(pixels, bounds_in_pixel);
 }
 
 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
   DCHECK_GT(scale, 0);
   if (size_in_pixel.IsEmpty() || scale <= 0)
     return;
   size_ = size_in_pixel;
-  host_->setViewportSize(size_in_pixel);
+  host_->setViewportSize(size_in_pixel, size_in_pixel);
   root_web_layer_->setBounds(size_in_pixel);
 
   if (device_scale_factor_ != scale) {
     device_scale_factor_ = scale;
     if (root_layer_)
       root_layer_->OnDeviceScaleFactorChanged(scale);
   }
 }
 
 void Compositor::AddObserver(CompositorObserver* observer) {
@@ skipping 31 matching lines @@
     if (posted_swaps_->NextPostedSwap() == DRAW_SWAP)
       NotifyEnd();
     posted_swaps_->EndSwap();
   }
 
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingAborted(this));
 }
 
-void Compositor::updateAnimations(double frameBeginTime) {
+void Compositor::willBeginFrame() {
+}
+
+void Compositor::didBeginFrame() {
+}
+
+void Compositor::animate(double frameBeginTime) {
 }
 
 void Compositor::layout() {
   // We're sending damage that will be addressed during this composite
   // cycle, so we don't need to schedule another composite to address it.
   disable_schedule_composite_ = true;
   if (root_layer_)
     root_layer_->SendDamagedRects();
   disable_schedule_composite_ = false;
 }
 
-void Compositor::applyScrollAndScale(const WebKit::WebSize& scrollDelta,
-                                     float scaleFactor) {
+void Compositor::applyScrollAndScale(gfx::Vector2d scrollDelta,
+                                     float pageScale) {
 }
 
-WebKit::WebCompositorOutputSurface* Compositor::createOutputSurface() {
+scoped_ptr<WebKit::WebCompositorOutputSurface>
+Compositor::createOutputSurface() {
   if (test_compositor_enabled) {
     ui::TestWebGraphicsContext3D* test_context =
       new ui::TestWebGraphicsContext3D();
     test_context->Initialize();
-    return new WebGraphicsContextToOutputSurfaceAdapter(test_context);
+    return scoped_ptr<WebKit::WebCompositorOutputSurface>(
+        new WebGraphicsContextToOutputSurfaceAdapter(test_context));
   } else {
-    return ContextFactory::GetInstance()->CreateOutputSurface(this);
+    return scoped_ptr<WebKit::WebCompositorOutputSurface>(
+        ContextFactory::GetInstance()->CreateOutputSurface(this));
   }
 }
 
 void Compositor::didRecreateOutputSurface(bool success) {
 }
 
+scoped_ptr<cc::InputHandler> Compositor::createInputHandler() {
+  return scoped_ptr<cc::InputHandler>();
+}
+
+void Compositor::willCommit() {
+}
+
 void Compositor::didCommit() {
   DCHECK(!IsLocked());
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingDidCommit(this));
 }
 
 void Compositor::didCommitAndDrawFrame() {
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
@@ skipping 59 matching lines @@
 
 COMPOSITOR_EXPORT void DisableTestCompositor() {
   test_compositor_enabled = false;
 }
 
 COMPOSITOR_EXPORT bool IsTestCompositorEnabled() {
   return test_compositor_enabled;
 }
 
 }  // namespace ui