Break Sky's dependency on cc

sky/viewer/document_view.cc

 // Copyright 2014 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 "sky/viewer/document_view.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 17 matching lines @@
 #include "sky/engine/public/web/WebInputEvent.h"
 #include "sky/engine/public/web/WebLocalFrame.h"
 #include "sky/engine/public/web/WebScriptSource.h"
 #include "sky/engine/public/web/WebSettings.h"
 #include "sky/engine/public/web/WebView.h"
 #include "sky/engine/v8_inspector/inspector_backend_mojo.h"
 #include "sky/engine/v8_inspector/inspector_host.h"
 #include "sky/viewer/converters/input_event_types.h"
 #include "sky/viewer/converters/url_request_types.h"
 #include "sky/viewer/internals.h"
-#include "sky/viewer/platform/weblayertreeview_impl.h"
 #include "sky/viewer/platform/weburlloader_impl.h"
 #include "sky/viewer/script/script_runner.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "v8/include/v8.h"
 
 namespace sky {
 namespace {
 
@@ skipping 19 matching lines @@
 }
 
 }  // namespace
 
 static int s_next_debugger_id = 1;
 
 DocumentView::DocumentView(
     const base::Closure& destruction_callback,
     mojo::ServiceProviderPtr provider,
     mojo::URLResponsePtr response,
-    mojo::Shell* shell,
-    scoped_refptr<base::MessageLoopProxy> compositor_thread)
+    mojo::Shell* shell)
     : destruction_callback_(destruction_callback),
       response_(response.Pass()),
       shell_(shell),
       web_view_(NULL),
       root_(NULL),
       view_manager_client_factory_(shell_, this),
       inspector_service_factory_(this),
-      compositor_thread_(compositor_thread),
       debugger_id_(s_next_debugger_id++),
       weak_factory_(this) {
   exported_services_.AddService(&view_manager_client_factory_);
   mojo::WeakBindToPipe(&exported_services_, provider.PassMessagePipe());
 }
 
 DocumentView::~DocumentView() {
   if (web_view_)
     web_view_->close();
   if (root_)
@@ skipping 16 matching lines @@
   navigator_host_.set_service_provider(imported_services_.get());
   exported_services->AddService(&inspector_service_factory_);
 
   Load(response_.Pass());
 
   gfx::Size size = root_->bounds().To<gfx::Rect>().size();
   web_view_->resize(size);
   // TODO(abarth): We should ask the view whether it is focused instead of
   // assuming that we're focused.
   web_view_->setFocus(true);
-#if !ENABLE_SKY_COMPOSITOR
-  web_layer_tree_view_impl_->setViewportSize(size);
-  web_layer_tree_view_impl_->set_view(root_);
-#endif
   root_->AddObserver(this);
 }
 
 void DocumentView::OnViewManagerDisconnected(mojo::ViewManager* view_manager) {
   // TODO(aa): Need to figure out how shutdown works.
 }
 
 void DocumentView::Load(mojo::URLResponsePtr response) {
   web_view_ = blink::WebView::create(this);
-#if !ENABLE_SKY_COMPOSITOR
-  web_layer_tree_view_impl_->set_widget(web_view_);
-#endif
   ConfigureSettings(web_view_->settings());
   web_view_->setMainFrame(blink::WebLocalFrame::create(this));
   web_view_->mainFrame()->load(GURL(response->url), response->body.Pass());
 }
 
 blink::WebLayerTreeView* DocumentView::initializeLayerTreeView() {
-#if ENABLE_SKY_COMPOSITOR
   layer_host_.reset(new LayerHost(this));
   root_layer_ = make_scoped_refptr(new Layer(this));
   layer_host_->SetRootLayer(root_layer_);
   return nullptr;
-#else
-  mojo::ServiceProviderPtr surfaces_service_provider;
-  shell_->ConnectToApplication("mojo:surfaces_service",
-                               mojo::GetProxy(&surfaces_service_provider));
-  mojo::InterfacePtr<mojo::SurfacesService> surfaces_service;
-  mojo::ConnectToService(surfaces_service_provider.get(), &surfaces_service);
-
-  mojo::ServiceProviderPtr gpu_service_provider;
-  // TODO(jamesr): Should be mojo:gpu_service
-  shell_->ConnectToApplication("mojo:native_viewport_service",
-                               mojo::GetProxy(&gpu_service_provider));
-  mojo::InterfacePtr<mojo::Gpu> gpu_service;
-  mojo::ConnectToService(gpu_service_provider.get(), &gpu_service);
-  web_layer_tree_view_impl_.reset(new WebLayerTreeViewImpl(
-      compositor_thread_, surfaces_service.Pass(), gpu_service.Pass()));
-
-  return web_layer_tree_view_impl_.get();
-#endif
 }
 
-#if ENABLE_SKY_COMPOSITOR
-
 mojo::Shell* DocumentView::GetShell() {
   return shell_;
 }
 
 void DocumentView::BeginFrame(base::TimeTicks frame_time) {
   double frame_time_sec = (frame_time - base::TimeTicks()).InSecondsF();
   double deadline_sec = frame_time_sec;
   double interval_sec = 1.0/60;
   blink::WebBeginFrameArgs web_begin_frame_args(
       frame_time_sec, deadline_sec, interval_sec);
   web_view_->beginFrame(web_begin_frame_args);
   web_view_->layout();
   blink::WebSize size = web_view_->size();
   root_layer_->SetSize(gfx::Size(size.width, size.height));
 }
 
 void DocumentView::OnSurfaceIdAvailable(mojo::SurfaceIdPtr surface_id) {
   root_->SetSurfaceId(surface_id.Pass());
 }
 
 void DocumentView::PaintContents(SkCanvas* canvas, const gfx::Rect& clip) {
   blink::WebRect rect(clip.x(), clip.y(), clip.width(), clip.height());
   web_view_->paint(canvas, rect);
 }
 
-#endif  // ENABLE_SKY_COMPOSITOR
-
 void DocumentView::scheduleAnimation() {
   DCHECK(web_view_);
-
-#if ENABLE_SKY_COMPOSITOR
   layer_host_->SetNeedsAnimate();
-#else
-  if (!web_view_->settings()->compositorIsEnabled())
-    web_layer_tree_view_impl_->setNeedsAnimate();
-#endif
 }
 
 mojo::View* DocumentView::createChildFrame(const blink::WebURL& url) {
   if (!root_)
     return nullptr;
 
   mojo::View* child = mojo::View::Create(root_->view_manager());
   child->SetVisible(true);
   root_->AddChild(child);
   child->Embed(mojo::String::From(url.string().utf8()));
@@ skipping 46 matching lines @@
 mojo::Shell* DocumentView::Shell() {
   return shell_;
 }
 
 void DocumentView::OnViewBoundsChanged(mojo::View* view,
                                        const mojo::Rect& old_bounds,
                                        const mojo::Rect& new_bounds) {
   DCHECK_EQ(view, root_);
   gfx::Size size = new_bounds.To<gfx::Rect>().size();
   web_view_->resize(size);
-#if !ENABLE_SKY_COMPOSITOR
-  web_layer_tree_view_impl_->setViewportSize(size);
-#endif
 }
 
 void DocumentView::OnViewFocusChanged(mojo::View* gained_focus,
                                       mojo::View* lost_focus) {
   if (root_ == lost_focus) {
     web_view_->setFocus(false);
   } else if (root_ == gained_focus) {
     web_view_->setFocus(true);
   }
 }
@@ skipping 33 matching lines @@
 void DocumentView::StartDebuggerInspectorBackend() {
   if (!inspector_backend_) {
     inspector_host_.reset(new InspectorHostImpl(web_view_, shell_));
     inspector_backend_.reset(
         new inspector::InspectorBackendMojo(inspector_host_.get()));
   }
   inspector_backend_->Connect();
 }
 
 }  // namespace sky