Plumbs through screen size and scale factor to html_viewer

components/html_viewer/html_document.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 "components/html_viewer/html_document.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/html_viewer/blink_input_events_type_converters.h"
 #include "components/html_viewer/blink_url_request_type_converters.h"
+#include "components/html_viewer/setup.h"
 #include "components/html_viewer/web_layer_tree_view_impl.h"
 #include "components/html_viewer/web_media_player_factory.h"
 #include "components/html_viewer/web_storage_namespace_impl.h"
 #include "components/html_viewer/web_url_loader_impl.h"
 #include "components/surfaces/public/interfaces/surfaces.mojom.h"
 #include "components/view_manager/public/cpp/view.h"
 #include "media/blink/webencryptedmediaclient_impl.h"
 #include "media/cdm/default_cdm_factory.h"
 #include "media/filters/default_media_permission.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/platform/WebSize.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/mojo/src/mojo/public/cpp/application/application_impl.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/connect.h"
 #include "third_party/mojo/src/mojo/public/cpp/system/data_pipe.h"
 #include "third_party/mojo/src/mojo/public/interfaces/application/shell.mojom.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 "ui/gfx/geometry/dip_util.h"
+#include "ui/gfx/geometry/size.h"
 
 using mojo::AxProvider;
 using mojo::Rect;
 using mojo::ServiceProviderPtr;
 using mojo::URLResponsePtr;
 using mojo::View;
 using mojo::ViewManager;
 using mojo::WeakBindToRequest;
 
 namespace html_viewer {
@@ skipping 58 matching lines @@
   // platform.
   return false;
 }
 
 }  // namespace
 
 HTMLDocument::HTMLDocument(
     mojo::InterfaceRequest<mojo::ServiceProvider> services,
     URLResponsePtr response,
     mojo::Shell* shell,
-    scoped_refptr<base::MessageLoopProxy> compositor_thread,
-    WebMediaPlayerFactory* web_media_player_factory,
-    bool is_headless)
+    Setup* setup)
     : response_(response.Pass()),
       shell_(shell),
       web_view_(nullptr),
       root_(nullptr),
       view_manager_client_factory_(shell_, this),
-      compositor_thread_(compositor_thread),
-      web_media_player_factory_(web_media_player_factory),
-      is_headless_(is_headless),
-      device_pixel_ratio_(1.0) {
+      setup_(setup) {
   exported_services_.AddService(this);
   exported_services_.AddService(&view_manager_client_factory_);
   exported_services_.Bind(services.Pass());
-  Load(response_.Pass());
+  if (setup_->did_init())
+    Load(response_.Pass());
 }
 
 HTMLDocument::~HTMLDocument() {
   STLDeleteElements(&ax_providers_);
   STLDeleteElements(&ax_provider_requests_);
 
   if (web_view_)
     web_view_->close();
   if (root_)
     root_->RemoveObserver(this);
 }
 
 void HTMLDocument::OnEmbed(
     View* root,
     mojo::InterfaceRequest<mojo::ServiceProvider> services,
     mojo::ServiceProviderPtr exposed_services) {
-  DCHECK(!is_headless_);
+  DCHECK(!setup_->is_headless());
   root_ = root;
+  root_->AddObserver(this);
   embedder_service_provider_ = exposed_services.Pass();
   navigator_host_.set_service_provider(embedder_service_provider_.get());
-  UpdateWebviewSizeFromViewSize();
-  web_layer_tree_view_impl_->set_view(root_);
-  root_->AddObserver(this);
+
+  InitSetupAndLoadIfNecessary();
 }
 
 void HTMLDocument::OnViewManagerDisconnected(ViewManager* view_manager) {
   // TODO(aa): Need to figure out how shutdown works.
 }
 
 void HTMLDocument::Create(mojo::ApplicationConnection* connection,
                           mojo::InterfaceRequest<AxProvider> request) {
   if (!did_finish_load_) {
     // Cache AxProvider interface requests until the document finishes loading.
@@ skipping 21 matching lines @@
 
   blink::WebURLRequest web_request;
   web_request.initialize();
   web_request.setURL(url);
   web_request.setExtraData(extra_data);
 
   web_view_->mainFrame()->loadRequest(web_request);
 }
 
 void HTMLDocument::UpdateWebviewSizeFromViewSize() {
-  device_pixel_ratio_ = root_->viewport_metrics().device_pixel_ratio;
-  web_view_->setDeviceScaleFactor(device_pixel_ratio_);
+  web_view_->setDeviceScaleFactor(setup_->device_pixel_ratio());
   const gfx::Size size_in_pixels(root_->bounds().width, root_->bounds().height);
   const gfx::Size size_in_dips = gfx::ConvertSizeToDIP(
       root_->viewport_metrics().device_pixel_ratio, size_in_pixels);
   web_view_->resize(
       blink::WebSize(size_in_dips.width(), size_in_dips.height()));
   web_layer_tree_view_impl_->setViewportSize(size_in_pixels);
 }
 
+void HTMLDocument::InitSetupAndLoadIfNecessary() {
+  DCHECK(root_);
+  if (web_view_ || root_->viewport_metrics().device_pixel_ratio == 0.f)
+    return;
+
+  setup_->InitIfNecessary(gfx::Size(root_->viewport_metrics().size->width,
+                                    root_->viewport_metrics().size->height),
+                          root_->viewport_metrics().device_pixel_ratio);
+  Load(response_.Pass());
+
+  UpdateWebviewSizeFromViewSize();
+  web_layer_tree_view_impl_->set_view(root_);
+}
+
 blink::WebStorageNamespace* HTMLDocument::createSessionStorageNamespace() {
   return new WebStorageNamespaceImpl();
 }
 
 void HTMLDocument::initializeLayerTreeView() {
-  if (is_headless_) {
-    web_layer_tree_view_impl_.reset(
-        new WebLayerTreeViewImpl(compositor_thread_, nullptr, nullptr));
+  if (setup_->is_headless()) {
+    web_layer_tree_view_impl_.reset(new WebLayerTreeViewImpl(
+        setup_->compositor_thread(), nullptr, nullptr));
     return;
   }
 
   ServiceProviderPtr surfaces_service_provider;
   shell_->ConnectToApplication("mojo:surfaces_service",
                                GetProxy(&surfaces_service_provider), nullptr);
   mojo::SurfacePtr surface;
   ConnectToService(surfaces_service_provider.get(), &surface);
 
   ServiceProviderPtr gpu_service_provider;
   // TODO(jamesr): Should be mojo:gpu_service
   shell_->ConnectToApplication("mojo:native_viewport_service",
                                GetProxy(&gpu_service_provider), nullptr);
   mojo::GpuPtr gpu_service;
   ConnectToService(gpu_service_provider.get(), &gpu_service);
   web_layer_tree_view_impl_.reset(new WebLayerTreeViewImpl(
-      compositor_thread_, surface.Pass(), gpu_service.Pass()));
+      setup_->compositor_thread(), surface.Pass(), gpu_service.Pass()));
 }
 
 blink::WebLayerTreeView* HTMLDocument::layerTreeView() {
   return web_layer_tree_view_impl_.get();
 }
 
 blink::WebMediaPlayer* HTMLDocument::createMediaPlayer(
     blink::WebLocalFrame* frame,
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client) {
   return createMediaPlayer(frame, url, client, nullptr);
 }
 
 blink::WebMediaPlayer* HTMLDocument::createMediaPlayer(
     blink::WebLocalFrame* frame,
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client,
     blink::WebContentDecryptionModule* initial_cdm) {
   blink::WebMediaPlayer* player =
-      web_media_player_factory_
-          ? web_media_player_factory_->CreateMediaPlayer(
+      setup_->web_media_player_factory()
+          ? setup_->web_media_player_factory()->CreateMediaPlayer(
                 frame, url, client, GetMediaPermission(), GetCdmFactory(),
                 initial_cdm, shell_)
           : nullptr;
   return player;
 }
 
 blink::WebFrame* HTMLDocument::createChildFrame(
     blink::WebLocalFrame* parent,
     const blink::WebString& frameName,
     blink::WebSandboxFlags sandboxFlags) {
@@ skipping 70 matching lines @@
   return web_encrypted_media_client_.get();
 }
 
 void HTMLDocument::OnViewBoundsChanged(View* view,
                                        const Rect& old_bounds,
                                        const Rect& new_bounds) {
   DCHECK_EQ(view, root_);
   UpdateWebviewSizeFromViewSize();
 }
 
+void HTMLDocument::OnViewViewportMetricsChanged(
+    mojo::View* view,
+    const mojo::ViewportMetrics& old_metrics,
+    const mojo::ViewportMetrics& new_metrics) {
+  InitSetupAndLoadIfNecessary();
+}
+
 void HTMLDocument::OnViewDestroyed(View* view) {
   DCHECK_EQ(view, root_);
   root_ = nullptr;
   delete this;
   mojo::ApplicationImpl::Terminate();
 }
 
 void HTMLDocument::OnViewInputEvent(View* view, const mojo::EventPtr& event) {
   if (event->pointer_data) {
     // Blink expects coordintes to be in DIPs.
-    event->pointer_data->x /= device_pixel_ratio_;
-    event->pointer_data->y /= device_pixel_ratio_;
-    event->pointer_data->screen_x /= device_pixel_ratio_;
-    event->pointer_data->screen_y /= device_pixel_ratio_;
+    event->pointer_data->x /= setup_->device_pixel_ratio();
+    event->pointer_data->y /= setup_->device_pixel_ratio();
+    event->pointer_data->screen_x /= setup_->device_pixel_ratio();
+    event->pointer_data->screen_y /= setup_->device_pixel_ratio();
   }
 
   if ((event->action == mojo::EVENT_TYPE_POINTER_DOWN ||
        event->action == mojo::EVENT_TYPE_POINTER_UP ||
        event->action == mojo::EVENT_TYPE_POINTER_CANCEL ||
        event->action == mojo::EVENT_TYPE_POINTER_MOVE) &&
       event->pointer_data->kind == mojo::POINTER_KIND_TOUCH) {
     touch_handler_->OnTouchEvent(*event);
     return;
   }
   scoped_ptr<blink::WebInputEvent> web_event =
       event.To<scoped_ptr<blink::WebInputEvent>>();
   if (web_event)
     web_view_->handleInputEvent(*web_event);
 }
 
 media::MediaPermission* HTMLDocument::GetMediaPermission() {
   if (!media_permission_)
     media_permission_.reset(new media::DefaultMediaPermission(true));
   return media_permission_.get();
 }
 
 media::CdmFactory* HTMLDocument::GetCdmFactory() {
   if (!cdm_factory_)
     cdm_factory_.reset(new media::DefaultCdmFactory());
   return cdm_factory_.get();
 }
 
 }  // namespace html_viewer