Revert "Compositor bindings for mojo html_viewer"

mojo/services/html_viewer/html_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 "mojo/services/html_viewer/html_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"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
 #include "mojo/services/html_viewer/blink_input_events_type_converters.h"
 #include "mojo/services/html_viewer/blink_url_request_type_converters.h"
-#include "mojo/services/html_viewer/weblayertreeview_impl.h"
 #include "mojo/services/html_viewer/webstoragenamespace_impl.h"
 #include "mojo/services/html_viewer/weburlloader_impl.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
-#include "mojo/services/public/interfaces/surfaces/surfaces_service.mojom.h"
 #include "skia/ext/refptr.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSettings.h"
 #include "third_party/WebKit/public/web/WebView.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"
 
 namespace mojo {
 namespace {
 
 void ConfigureSettings(blink::WebSettings* settings) {
+  settings->setAcceleratedCompositingEnabled(false);
   settings->setCookieEnabled(true);
   settings->setDefaultFixedFontSize(13);
   settings->setDefaultFontSize(16);
   settings->setLoadsImagesAutomatically(true);
   settings->setJavaScriptEnabled(true);
 }
 
 Target WebNavigationPolicyToNavigationTarget(
     blink::WebNavigationPolicy policy) {
   switch (policy) {
@@ skipping 26 matching lines @@
   // Otherwise we don't know if we're the right app to handle this request. Ask
   // host to do the navigation for us.
   return false;
 }
 
 }  // namespace
 
 HTMLDocumentView::HTMLDocumentView(
     URLResponsePtr response,
     InterfaceRequest<ServiceProvider> service_provider_request,
-    Shell* shell,
-    scoped_refptr<base::MessageLoopProxy> compositor_thread)
+    Shell* shell)
     : shell_(shell),
       web_view_(NULL),
       root_(NULL),
       view_manager_client_factory_(shell, this),
-      compositor_thread_(compositor_thread),
+      repaint_pending_(false),
       weak_factory_(this) {
   ServiceProviderImpl* exported_services = new ServiceProviderImpl();
   exported_services->AddService(&view_manager_client_factory_);
   BindToRequest(exported_services, &service_provider_request);
   Load(response.Pass());
 }
 
 HTMLDocumentView::~HTMLDocumentView() {
   if (web_view_)
     web_view_->close();
   if (root_)
     root_->RemoveObserver(this);
 }
 
 void HTMLDocumentView::OnEmbed(
     ViewManager* view_manager,
     View* root,
     ServiceProviderImpl* embedee_service_provider_impl,
     scoped_ptr<ServiceProvider> embedder_service_provider) {
   root_ = root;
   embedder_service_provider_ = embedder_service_provider.Pass();
   navigator_host_.set_service_provider(embedder_service_provider_.get());
 
+  root_->SetColor(SK_ColorCYAN);  // Dummy background color.
   web_view_->resize(root_->bounds().size());
-  web_layer_tree_view_impl_->setViewportSize(root_->bounds().size());
-  web_layer_tree_view_impl_->set_view(root_);
   root_->AddObserver(this);
 }
 
 void HTMLDocumentView::OnViewManagerDisconnected(ViewManager* view_manager) {
   // TODO(aa): Need to figure out how shutdown works.
 }
 
 void HTMLDocumentView::Load(URLResponsePtr response) {
   web_view_ = blink::WebView::create(this);
-  web_layer_tree_view_impl_->set_widget(web_view_);
   ConfigureSettings(web_view_->settings());
   web_view_->setMainFrame(blink::WebLocalFrame::create(this));
 
   GURL url(response->url);
 
   WebURLRequestExtraData* extra_data = new WebURLRequestExtraData;
   extra_data->synthetic_response = response.Pass();
 
   blink::WebURLRequest web_request;
   web_request.initialize();
   web_request.setURL(url);
   web_request.setExtraData(extra_data);
 
   web_view_->mainFrame()->loadRequest(web_request);
 }
 
 blink::WebStorageNamespace* HTMLDocumentView::createSessionStorageNamespace() {
   return new WebStorageNamespaceImpl();
 }
 
-void HTMLDocumentView::initializeLayerTreeView() {
-  ServiceProviderPtr surfaces_service_provider;
-  shell_->ConnectToApplication("mojo:mojo_surfaces_service",
-                               Get(&surfaces_service_provider));
-  InterfacePtr<SurfacesService> surfaces_service;
-  ConnectToService(surfaces_service_provider.get(), &surfaces_service);
-
-  ServiceProviderPtr gpu_service_provider;
-  // TODO(jamesr): Should be mojo:mojo_gpu_service
-  shell_->ConnectToApplication("mojo:mojo_native_viewport_service",
-                               Get(&gpu_service_provider));
-  InterfacePtr<Gpu> gpu_service;
-  ConnectToService(gpu_service_provider.get(), &gpu_service);
-  web_layer_tree_view_impl_.reset(new WebLayerTreeViewImpl(
-      compositor_thread_, surfaces_service.Pass(), gpu_service.Pass()));
+void HTMLDocumentView::didInvalidateRect(const blink::WebRect& rect) {
+  if (!repaint_pending_) {
+    repaint_pending_ = true;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(&HTMLDocumentView::Repaint, weak_factory_.GetWeakPtr()));
+  }
 }
 
-blink::WebLayerTreeView* HTMLDocumentView::layerTreeView() {
-  return web_layer_tree_view_impl_.get();
+bool HTMLDocumentView::allowsBrokenNullLayerTreeView() const {
+  // TODO(darin): Switch to using compositor bindings.
+  //
+  // NOTE: Note to Blink maintainers, feel free to break this code if it is the
+  // last NOT using compositor bindings and you want to delete this code path.
+  //
+  return true;
 }
 
 blink::WebFrame* HTMLDocumentView::createChildFrame(
     blink::WebLocalFrame* parent,
     const blink::WebString& frameName) {
   blink::WebLocalFrame* web_frame = blink::WebLocalFrame::create(this);
   parent->appendChild(web_frame);
   return web_frame;
 }
 
@@ skipping 51 matching lines @@
   root_ = NULL;
 }
 
 void HTMLDocumentView::OnViewInputEvent(View* view, const EventPtr& event) {
   scoped_ptr<blink::WebInputEvent> web_event =
       event.To<scoped_ptr<blink::WebInputEvent> >();
   if (web_event)
     web_view_->handleInputEvent(*web_event);
 }
 
+void HTMLDocumentView::Repaint() {
+  repaint_pending_ = false;
+
+  if (!root_)
+    return;
+
+  web_view_->animate(0.0);
+  web_view_->layout();
+
+  int width = web_view_->size().width;
+  int height = web_view_->size().height;
+
+  skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(SkCanvas::NewRaster(
+      SkImageInfo::MakeN32(width, height, kOpaque_SkAlphaType)));
+
+  web_view_->paint(canvas.get(), gfx::Rect(0, 0, width, height));
+
+  root_->SetContents(canvas->getDevice()->accessBitmap(false));
+}
+
 }  // namespace mojo