Teach sky_viewer about the new main.dart hotness

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 132 matching lines @@
 
   services_provided_to_embedder_ = services_provided_to_embedder.Pass();
   services_provided_by_embedder_ = services_provided_by_embedder.Pass();
 
   Load(response_.Pass());
 
   UpdateRootSizeAndViewportMetrics(root_->bounds());
 
   // TODO(abarth): We should ask the view whether it is focused instead of
   // assuming that we're focused.
-  web_view_->setFocus(true);
+  if (web_view_)
+    web_view_->setFocus(true);
   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) {
+  // Enable SkyView here.
+  if (false) {
+    sky_view_ = blink::SkyView::Create(this);
+    initializeLayerTreeView();
+    sky_view_->Load(GURL(response->url), response.Pass());
+    return;
+  }
+
   web_view_ = blink::WebView::create(this);
   ConfigureSettings(web_view_->settings());
   web_view_->setMainFrame(blink::WebLocalFrame::create(this));
   web_view_->mainFrame()->loadFromDataPipeWithURL(
       response->body.Pass(), GURL(response->url));
 }
 
 void DocumentView::initializeLayerTreeView() {
   layer_host_.reset(new LayerHost(this));
   root_layer_ = make_scoped_refptr(new Layer(this));
@@ skipping 31 matching lines @@
 
 mojo::ScopedMessagePipeHandle DocumentView::TakeServiceRegistry() {
   return service_registry_.PassInterface().PassHandle();
 }
 
 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();
-  float device_pixel_ratio = GetDevicePixelRatio();
-  root_layer_->SetSize(gfx::Size(size.width * device_pixel_ratio,
-                                 size.height * device_pixel_ratio));
+  if (sky_view_) {
+    sky_view_->BeginFrame(frame_time);
+    root_layer_->SetSize(sky_view_->display_metrics().physical_size);
+  }
+  if (web_view_) {
+    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();
+    float device_pixel_ratio = GetDevicePixelRatio();
+    root_layer_->SetSize(gfx::Size(size.width * device_pixel_ratio,
+                                   size.height * device_pixel_ratio));
+  }
 }
 
 void DocumentView::OnSurfaceIdAvailable(mojo::SurfaceIdPtr surface_id) {
   if (root_)
     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);
+
+  if (sky_view_) {
+    skia::RefPtr<SkPicture> picture = sky_view_->Paint();
+    canvas->clear(SK_ColorBLACK);
+    canvas->scale(GetDevicePixelRatio(), GetDevicePixelRatio());
+    if (picture)
+      canvas->drawPicture(picture.get());
+  }
+
+  if (web_view_)
+    web_view_->paint(canvas, rect);
 }
 
 void DocumentView::scheduleVisualUpdate() {
-  DCHECK(web_view_);
   layer_host_->SetNeedsAnimate();
 }
 
 blink::WebScreenInfo DocumentView::screenInfo() {
   DCHECK(root_);
   auto& metrics = root_->viewport_metrics();
   blink::WebScreenInfo screen;
   screen.rect = blink::WebRect(0, 0, metrics.size->width, metrics.size->height);
   screen.availableRect = screen.rect;
   screen.deviceScaleFactor = metrics.device_pixel_ratio;
@@ skipping 58 matching lines @@
                                        const mojo::Rect& new_bounds) {
   DCHECK_EQ(view, root_);
   UpdateRootSizeAndViewportMetrics(new_bounds);
 }
 
 void DocumentView::OnViewViewportMetricsChanged(
     mojo::View* view,
     const mojo::ViewportMetrics& old_metrics,
     const mojo::ViewportMetrics& new_metrics) {
   DCHECK_EQ(view, root_);
-  web_view_->setDeviceScaleFactor(GetDevicePixelRatio());
+
+  if (web_view_) {
+    web_view_->setDeviceScaleFactor(GetDevicePixelRatio());
+  }
   UpdateRootSizeAndViewportMetrics(root_->bounds());
 }
 
 void DocumentView::UpdateRootSizeAndViewportMetrics(
     const mojo::Rect& new_bounds) {
   float device_pixel_ratio = GetDevicePixelRatio();
+
+  if (sky_view_) {
+    blink::SkyDisplayMetrics metrics;
+    mojo::Rect bounds = root_->bounds();
+    metrics.physical_size = blink::WebSize(bounds.width, bounds.height);
+    metrics.device_pixel_ratio = device_pixel_ratio;
+    sky_view_->SetDisplayMetrics(metrics);
+    return;
+  }
+
   web_view_->resize(blink::WebSize(new_bounds.width / device_pixel_ratio,
                                    new_bounds.height / device_pixel_ratio));
 }
 
 void DocumentView::OnViewFocusChanged(mojo::View* gained_focus,
                                       mojo::View* lost_focus) {
+  if (sky_view_)
+    return;
   if (root_ == lost_focus) {
     web_view_->setFocus(false);
   } else if (root_ == gained_focus) {
     web_view_->setFocus(true);
   }
 }
 
 void DocumentView::OnViewDestroyed(mojo::View* view) {
   DCHECK_EQ(view, root_);
 
   root_ = nullptr;
 }
 
 void DocumentView::OnViewInputEvent(
     mojo::View* view, const mojo::EventPtr& event) {
   float device_pixel_ratio = GetDevicePixelRatio();
   scoped_ptr<blink::WebInputEvent> web_event =
       ConvertEvent(event, device_pixel_ratio);
   if (!web_event)
     return;
 
+  if (sky_view_) {
+    sky_view_->HandleInputEvent(*web_event);
+    return;
+  }
+
   ui::GestureRecognizer* recognizer = ui::GestureRecognizer::Get();
   scoped_ptr<ui::TouchEvent> touch_event =
       ConvertToUITouchEvent(*web_event, device_pixel_ratio);
   if (touch_event)
     recognizer->ProcessTouchEventPreDispatch(*touch_event, this);
 
   bool handled = web_view_->handleInputEvent(*web_event);
 
   if (touch_event) {
     ui::EventResult result = handled ? ui::ER_UNHANDLED : ui::ER_UNHANDLED;
@@ skipping 18 matching lines @@
   mojo::Array<mojo::String> interface_names(1);
   interface_names[0] = mojo::ViewManagerClient::Name_;
   mojo::ServiceProviderImpl* sp_impl(new mojo::ServiceProviderImpl());
   sp_impl->AddService(&view_manager_client_factory_);
   mojo::ServiceProviderPtr sp;
   service_registry_service_provider_binding_.reset(
       new mojo::StrongBinding<mojo::ServiceProvider>(sp_impl, &sp));
   service_registry_->AddServices(interface_names.Pass(), sp.Pass());
 }
 
+void DocumentView::ScheduleFrame() {
+  DCHECK(sky_view_);
+  layer_host_->SetNeedsAnimate();
+}
+
 }  // namespace sky