Plumbs through screen size and scale factor to html_viewer

As ResourceBundle uses the scale factor we gate loading until we know
the scale factor.

I also made it so ViewportMetrics::device_scale_factor is 0 until we have a real value. This way ViewManager clients have a way to know when the real value is available.

BUG=none
TEST=none
R=ben@chromium.org

Review URL: https://codereview.chromium.org/1136743003

Cr-Commit-Position: refs/heads/master@{#329514}

components/html_viewer/BUILD.gn

@@ -75,6 +75,8 @@ source_set("lib") {
     "html_document.h",
     "mock_web_blob_registry_impl.cc",
     "mock_web_blob_registry_impl.h",
+    "setup.cc",
+    "setup.h",
     "touch_handler.cc",
     "touch_handler.h",
     "web_clipboard_impl.cc",
@@ -113,6 +115,8 @@ source_set("lib") {
     "//components/clipboard/public/interfaces",
     "//components/gpu/public/interfaces",
     "//components/mime_util",
+    "//components/resource_provider/public/cpp",
+    "//components/resource_provider/public/interfaces",
     "//components/scheduler:scheduler",
     "//components/surfaces/public/interfaces",
     "//components/webcrypto",
@@ -177,8 +181,6 @@ mojo_application_package("html_viewer") {
   deps = [
     ":html_viewer_resources_grit",
     ":lib",
-    "//components/resource_provider/public/cpp",
-    "//components/resource_provider/public/interfaces",
     "//mojo/common",
     "//mojo/platform_handle",
     "//third_party/icu:icudata",
@@ -223,10 +225,13 @@ mojo_native_application("apptests") {
   ]
 
   deps = [
-    ":lib",
-    ":html_viewer",
+    "//base",
+    "//mojo/application",
     "//mojo/application:test_support",
     "//net:test_support",
     "//testing/gtest",
+    "//third_party/mojo_services/src/accessibility/public/interfaces",
   ]
+
+  data_deps = [ ":html_viewer" ]
 }

components/html_viewer/html_document.cc

@@ -14,6 +14,7 @@
 #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"
@@ -43,6 +44,7 @@
 #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;
@@ -121,22 +123,18 @@ 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() {
@@ -153,13 +151,13 @@ 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) {
@@ -201,8 +199,7 @@ void HTMLDocument::Load(URLResponsePtr response) {
 }
 
 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);
@@ -211,14 +208,28 @@ void HTMLDocument::UpdateWebviewSizeFromViewSize() {
   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;
   }
 
@@ -235,7 +246,7 @@ void HTMLDocument::initializeLayerTreeView() {
   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() {
@@ -255,8 +266,8 @@ blink::WebMediaPlayer* HTMLDocument::createMediaPlayer(
     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;
@@ -347,6 +358,13 @@ void HTMLDocument::OnViewBoundsChanged(View* view,
   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;
@@ -357,10 +375,10 @@ void HTMLDocument::OnViewDestroyed(View* view) {
 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 ||

components/html_viewer/html_document.h

@@ -44,6 +44,7 @@ class View;
 namespace html_viewer {
 
 class AxProviderImpl;
+class Setup;
 class WebLayerTreeViewImpl;
 class WebMediaPlayerFactory;
 
@@ -65,9 +66,7 @@ class HTMLDocument : public blink::WebViewClient,
   HTMLDocument(mojo::InterfaceRequest<mojo::ServiceProvider> services,
                mojo::URLResponsePtr response,
                mojo::Shell* shell,
-               scoped_refptr<base::MessageLoopProxy> compositor_thread,
-               WebMediaPlayerFactory* web_media_player_factory,
-               bool is_headless);
+               Setup* setup);
   ~HTMLDocument() override;
 
  private:
@@ -75,6 +74,8 @@ class HTMLDocument : public blink::WebViewClient,
   // |root_|.
   void UpdateWebviewSizeFromViewSize();
 
+  void InitSetupAndLoadIfNecessary();
+
   // WebViewClient methods:
   virtual blink::WebStorageNamespace* createSessionStorageNamespace();
 
@@ -125,6 +126,10 @@ class HTMLDocument : public blink::WebViewClient,
   void OnViewBoundsChanged(mojo::View* view,
                            const mojo::Rect& old_bounds,
                            const mojo::Rect& new_bounds) override;
+  void OnViewViewportMetricsChanged(
+      mojo::View* view,
+      const mojo::ViewportMetrics& old_metrics,
+      const mojo::ViewportMetrics& new_metrics) override;
   void OnViewDestroyed(mojo::View* view) override;
   void OnViewInputEvent(mojo::View* view, const mojo::EventPtr& event) override;
 
@@ -162,13 +167,10 @@ class HTMLDocument : public blink::WebViewClient,
   // A flag set on didFinishLoad.
   bool did_finish_load_ = false;
 
-  // Set if the content will never be displayed.
-  bool is_headless_;
+  Setup* setup_;
 
   scoped_ptr<TouchHandler> touch_handler_;
 
-  float device_pixel_ratio_;
-
   DISALLOW_COPY_AND_ASSIGN(HTMLDocument);
 };
 

components/html_viewer/setup.cc

+// Copyright 2015 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/setup.h"
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/i18n/icu_util.h"
+#include "base/logging.h"
+#include "components/html_viewer/blink_platform_impl.h"
+#include "components/html_viewer/web_media_player_factory.h"
+#include "components/scheduler/renderer/renderer_scheduler.h"
+#include "gin/v8_initializer.h"
+#include "third_party/WebKit/public/web/WebKit.h"
+#include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
+#include "third_party/mojo/src/mojo/public/cpp/application/application_impl.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "ui/base/ui_base_paths.h"
+
+#if defined(OS_ANDROID)
+#include "components/html_viewer/ui_setup_android.h"
+#else
+#include "components/html_viewer/ui_setup.h"
+#endif
+
+namespace html_viewer {
+
+namespace {
+
+// Enable MediaRenderer in media pipeline instead of using the internal
+// media::Renderer implementation.
+const char kEnableMojoMediaRenderer[] = "enable-mojo-media-renderer";
+
+// Disables support for (unprefixed) Encrypted Media Extensions.
+const char kDisableEncryptedMedia[] = "disable-encrypted-media";
+
+// Prevents creation of any output surface.
+const char kIsHeadless[] = "is-headless";
+
+size_t kDesiredMaxMemory = 20 * 1024 * 1024;
+
+// Paths resources are loaded from.
+const char kResourceIcudtl[] = "icudtl.dat";
+const char kResourceResourcesPak[] = "html_viewer_resources.pak";
+const char kResourceUIPak[] = "ui_test.pak";
+#if defined(V8_USE_EXTERNAL_STARTUP_DATA)
+const char kResourceNativesBlob[] = "natives_blob.bin";
+const char kResourceSnapshotBlob[] = "snapshot_blob.bin";
+#endif
+
+std::set<std::string> GetResourcePaths() {
+  std::set<std::string> paths;
+  paths.insert(kResourceResourcesPak);
+  paths.insert(kResourceIcudtl);
+  paths.insert(kResourceUIPak);
+#if defined(V8_USE_EXTERNAL_STARTUP_DATA)
+  paths.insert(kResourceNativesBlob);
+  paths.insert(kResourceSnapshotBlob);
+#endif
+  return paths;
+}
+
+}  // namespace
+
+Setup::Setup(mojo::ApplicationImpl* app)
+    : app_(app),
+      resource_loader_(app->shell(), GetResourcePaths()),
+      is_headless_(
+          base::CommandLine::ForCurrentProcess()->HasSwitch(kIsHeadless)),
+      did_init_(false),
+      device_pixel_ratio_(1.f),
+      discardable_memory_allocator_(kDesiredMaxMemory),
+      compositor_thread_("compositor thread") {
+  if (is_headless_)
+    InitHeadless();
+}
+
+Setup::~Setup() {
+}
+
+void Setup::InitHeadless() {
+  DCHECK(!did_init_);
+  is_headless_ = true;
+  InitIfNecessary(gfx::Size(1024, 1024), 1.f);
+}
+
+void Setup::InitIfNecessary(const gfx::Size& screen_size_in_pixels,
+                            float device_pixel_ratio) {
+  if (did_init_)
+    return;
+
+  DCHECK_NE(0.f, device_pixel_ratio);
+
+  did_init_ = true;
+  device_pixel_ratio_ = device_pixel_ratio;
+  screen_size_in_pixels_ = screen_size_in_pixels;
+
+  if (!resource_loader_.BlockUntilLoaded()) {
+    // Assume on error we're being shut down.
+    mojo::ApplicationImpl::Terminate();
+    return;
+  }
+
+  ui_setup_.reset(new UISetup(screen_size_in_pixels, device_pixel_ratio));
+  base::DiscardableMemoryAllocator::SetInstance(&discardable_memory_allocator_);
+
+  renderer_scheduler_ = scheduler::RendererScheduler::Create();
+  blink_platform_.reset(new BlinkPlatformImpl(app_, renderer_scheduler_.get()));
+#if defined(V8_USE_EXTERNAL_STARTUP_DATA)
+  CHECK(gin::V8Initializer::LoadV8SnapshotFromFD(
+      resource_loader_.ReleaseFile(kResourceNativesBlob).TakePlatformFile(), 0u,
+      0u,
+      resource_loader_.ReleaseFile(kResourceSnapshotBlob).TakePlatformFile(),
+      0u, 0u));
+#endif
+  blink::initialize(blink_platform_.get());
+  base::i18n::InitializeICUWithFileDescriptor(
+      resource_loader_.ReleaseFile(kResourceIcudtl).TakePlatformFile(),
+      base::MemoryMappedFile::Region::kWholeFile);
+
+  ui::RegisterPathProvider();
+
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+
+  logging::LoggingSettings settings;
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+  logging::InitLogging(settings);
+  // Display process ID, thread ID and timestamp in logs.
+  logging::SetLogItems(true, true, true, false);
+
+  if (command_line->HasSwitch(kDisableEncryptedMedia))
+    blink::WebRuntimeFeatures::enableEncryptedMedia(false);
+
+  if (!is_headless_) {
+    ui::ResourceBundle::InitSharedInstanceWithPakFileRegion(
+        resource_loader_.ReleaseFile(kResourceResourcesPak),
+        base::MemoryMappedFile::Region::kWholeFile);
+    // TODO(sky): why is this always using 100?
+    ui::ResourceBundle::GetSharedInstance().AddDataPackFromFile(
+        resource_loader_.ReleaseFile(kResourceUIPak), ui::SCALE_FACTOR_100P);
+  }
+
+  compositor_thread_.Start();
+#if defined(OS_ANDROID)
+  // TODO(sky): Get WebMediaPlayerFactory working on android.
+  NOTIMPLEMENTED();
+#else
+  bool enable_mojo_media_renderer =
+      command_line->HasSwitch(kEnableMojoMediaRenderer);
+
+  web_media_player_factory_.reset(new WebMediaPlayerFactory(
+      compositor_thread_.message_loop_proxy(), enable_mojo_media_renderer));
+#endif
+}
+
+}  // namespace html_viewer

components/html_viewer/setup.h

+// Copyright 2015 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.
+
+#ifndef COMPONENTS_HTML_VIEWER_SETUP_H_
+#define COMPONENTS_HTML_VIEWER_SETUP_H_
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/threading/thread.h"
+#include "components/html_viewer/discardable_memory_allocator.h"
+#include "components/resource_provider/public/cpp/resource_loader.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace mojo {
+class ApplicationImpl;
+class Shell;
+}
+
+namespace scheduler {
+class RendererScheduler;
+}
+
+namespace html_viewer {
+
+class BlinkPlatformImpl;
+class UISetup;
+class WebMediaPlayerFactory;
+
+// Setup encapsulates the necessary state needed by HTMLViewer. Some objects
+// are created immediately in the constructor, otherwise not until
+// InitIfNecessary() is invoked.
+// Setup can be initialized in two distinct ways:
+// . headless: this is determined by the command line, but can be forced by way
+//   of InitHeadless().
+// . with a ui: this is done via InitIfNecessary().
+class Setup {
+ public:
+  explicit Setup(mojo::ApplicationImpl* app);
+  ~Setup();
+
+  // Use to explicitly create headless regardless of command line switches.
+  // This must be invoked before InitIfNecessary().
+  void InitHeadless();
+
+  // Inits with the specified screen size and device pixel ratio.
+  // NOTE: we wait to complete setup until the device pixel ratio is available
+  // as ResourceBundle uses the device pixel ratio during initialization.
+  void InitIfNecessary(const gfx::Size& screen_size_in_pixels,
+                       float device_pixel_ratio);
+
+  bool is_headless() const { return is_headless_; }
+
+  bool did_init() const { return did_init_; }
+
+  const gfx::Size& screen_size_in_pixels() const {
+    return screen_size_in_pixels_;
+  }
+
+  float device_pixel_ratio() const { return device_pixel_ratio_; }
+
+  scoped_refptr<base::MessageLoopProxy> compositor_thread() {
+    return compositor_thread_.message_loop_proxy();
+  }
+
+  WebMediaPlayerFactory* web_media_player_factory() {
+    return web_media_player_factory_.get();
+  }
+
+ private:
+  mojo::ApplicationImpl* app_;
+
+  resource_provider::ResourceLoader resource_loader_;
+
+  bool is_headless_;
+
+  // True once we've completed init.
+  bool did_init_;
+
+  float device_pixel_ratio_;
+
+  gfx::Size screen_size_in_pixels_;
+
+  scoped_ptr<UISetup> ui_setup_;
+
+  // Skia requires that we have one of these. Unlike the one used in chrome,
+  // this doesn't use purgable shared memory. Instead, it tries to free the
+  // oldest unlocked chunks on allocation.
+  //
+  // TODO(erg): In the long run, delete this allocator and get the real shared
+  // memory based purging allocator working here.
+  DiscardableMemoryAllocator discardable_memory_allocator_;
+
+  scoped_ptr<scheduler::RendererScheduler> renderer_scheduler_;
+  scoped_ptr<BlinkPlatformImpl> blink_platform_;
+  base::Thread compositor_thread_;
+  scoped_ptr<WebMediaPlayerFactory> web_media_player_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(Setup);
+};
+
+}  // namespace html_viewer
+
+#endif  // COMPONENTS_HTML_VIEWER_SETUP_H_

components/html_viewer/ui_setup.h

@@ -7,12 +7,16 @@
 
 #include "base/basictypes.h"
 
+namespace gfx {
+class Size;
+}
+
 namespace html_viewer {
 
 // UISetup is intended for platform specific UI setup.
 class UISetup {
  public:
-  UISetup() {}
+  UISetup(const gfx::Size& screen_size_in_pixels, float device_pixel_ratio) {}
   ~UISetup() {}
 
  private:

components/html_viewer/ui_setup_android.cc

@@ -6,15 +6,18 @@
 
 #include "base/memory/singleton.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
+#include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/screen.h"
 
 namespace html_viewer {
 namespace {
 
-// TODO(sky): The values these serve up need to come from a service.
 class ScreenMandoline : public gfx::Screen {
  public:
-  ScreenMandoline() {}
+  ScreenMandoline(const gfx::Size& screen_size_in_pixels,
+                  float device_pixel_ratio)
+      : screen_size_in_pixels_(screen_size_in_pixels),
+        device_pixel_ratio_(device_pixel_ratio) {}
 
   gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
 
@@ -29,9 +32,11 @@ class ScreenMandoline : public gfx::Screen {
   }
 
   gfx::Display GetPrimaryDisplay() const override {
-    NOTIMPLEMENTED();
-    gfx::Display display(0, gfx::Rect(0, 0, 1000, 1000));
-    display.set_device_scale_factor(2.0f);
+    const gfx::Rect bounds_in_pixels(gfx::Point(), screen_size_in_pixels_);
+    const gfx::Rect bounds_in_dip(gfx::ToCeiledSize(
+        gfx::ScaleSize(bounds_in_pixels.size(), 1.0f / device_pixel_ratio_)));
+    gfx::Display display(0, bounds_in_dip);
+    display.set_device_scale_factor(device_pixel_ratio_);
     return display;
   }
 
@@ -62,11 +67,15 @@ class ScreenMandoline : public gfx::Screen {
   }
 
  private:
+  const gfx::Size screen_size_in_pixels_;
+  const float device_pixel_ratio_;
+
   DISALLOW_COPY_AND_ASSIGN(ScreenMandoline);
 };
 
 }  // namespace
 
+// TODO(sky): this needs to come from system.
 class GestureConfigurationMandoline : public ui::GestureConfiguration {
  public:
   GestureConfigurationMandoline() : GestureConfiguration() {
@@ -89,8 +98,9 @@ class GestureConfigurationMandoline : public ui::GestureConfiguration {
   DISALLOW_COPY_AND_ASSIGN(GestureConfigurationMandoline);
 };
 
-UISetup::UISetup()
-    : screen_(new ScreenMandoline),
+UISetup::UISetup(const gfx::Size& screen_size_in_pixels,
+                 float device_pixel_ratio)
+    : screen_(new ScreenMandoline(screen_size_in_pixels, device_pixel_ratio)),
       gesture_configuration_(new GestureConfigurationMandoline) {
   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
                                  screen_.get());

components/html_viewer/ui_setup_android.h

@@ -10,6 +10,7 @@
 
 namespace gfx {
 class Screen;
+class Size;
 }
 
 namespace ui {
@@ -22,7 +23,7 @@ class GestureConfigurationMandoline;
 
 class UISetup {
  public:
-  UISetup();
+  UISetup(const gfx::Size& screen_size_in_pixels, float device_pixel_ratio);
   ~UISetup();
 
  private:

components/native_viewport/android/src/org/chromium/mojo/PlatformViewportAndroid.java

@@ -54,7 +54,7 @@ public class PlatformViewportAndroid extends SurfaceView {
             @Override
             public void surfaceCreated(SurfaceHolder holder) {
                 assert mNativeMojoViewport != 0;
-                nativeSurfaceCreated(mNativeMojoViewport, holder.getSurface());
+                nativeSurfaceCreated(mNativeMojoViewport, holder.getSurface(), density);
             }
 
             @Override
@@ -167,7 +167,7 @@ public class PlatformViewportAndroid extends SurfaceView {
     private static native void nativeDestroy(long nativePlatformViewportAndroid);
 
     private static native void nativeSurfaceCreated(
-            long nativePlatformViewportAndroid, Surface surface);
+            long nativePlatformViewportAndroid, Surface surface, float devicePixelRatio);
 
     private static native void nativeSurfaceDestroyed(
             long nativePlatformViewportAndroid);

components/native_viewport/native_viewport_impl.cc

@@ -99,7 +99,9 @@ void NativeViewportImpl::OnMetricsChanged(mojo::ViewportMetricsPtr metrics) {
 }
 
 void NativeViewportImpl::OnAcceleratedWidgetAvailable(
-    gfx::AcceleratedWidget widget) {
+    gfx::AcceleratedWidget widget,
+    float device_pixel_ratio) {
+  metrics_->device_pixel_ratio = device_pixel_ratio;
   context_provider_.SetAcceleratedWidget(widget);
   // TODO: The metrics here might not match the actual window size on android
   // where we don't know the actual size until the first OnMetricsChanged call.

components/native_viewport/native_viewport_impl.h

@@ -53,7 +53,8 @@ class NativeViewportImpl : public mojo::NativeViewport,
 
   // PlatformViewport::Delegate implementation.
   void OnMetricsChanged(mojo::ViewportMetricsPtr metrics) override;
-  void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget) override;
+  void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget,
+                                    float device_pixel_ratio) override;
   void OnAcceleratedWidgetDestroyed() override;
   bool OnEvent(mojo::EventPtr event) override;
   void OnDestroyed() override;

components/native_viewport/platform_viewport.h

@@ -25,8 +25,8 @@ class PlatformViewport {
     virtual ~Delegate() {}
 
     virtual void OnMetricsChanged(mojo::ViewportMetricsPtr metrics) = 0;
-    virtual void OnAcceleratedWidgetAvailable(
-        gfx::AcceleratedWidget widget) = 0;
+    virtual void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget,
+                                              float device_pixel_ratio) = 0;
     virtual void OnAcceleratedWidgetDestroyed() = 0;
     virtual bool OnEvent(mojo::EventPtr event) = 0;
     virtual void OnDestroyed() = 0;

components/native_viewport/platform_viewport_android.cc

@@ -74,7 +74,8 @@ void PlatformViewportAndroid::Destroy(JNIEnv* env, jobject obj) {
 
 void PlatformViewportAndroid::SurfaceCreated(JNIEnv* env,
                                              jobject obj,
-                                             jobject jsurface) {
+                                             jobject jsurface,
+                                             float device_pixel_ratio) {
   base::android::ScopedJavaLocalRef<jobject> protector(env, jsurface);
   // Note: This ensures that any local references used by
   // ANativeWindow_fromSurface are released immediately. This is needed as a
@@ -83,7 +84,7 @@ void PlatformViewportAndroid::SurfaceCreated(JNIEnv* env,
     base::android::ScopedJavaLocalFrame scoped_local_reference_frame(env);
     window_ = ANativeWindow_fromSurface(env, jsurface);
   }
-  delegate_->OnAcceleratedWidgetAvailable(window_);
+  delegate_->OnAcceleratedWidgetAvailable(window_, device_pixel_ratio);
 }
 
 void PlatformViewportAndroid::SurfaceDestroyed(JNIEnv* env, jobject obj) {

components/native_viewport/platform_viewport_android.h

@@ -30,7 +30,10 @@ class PlatformViewportAndroid : public PlatformViewport {
   ~PlatformViewportAndroid() override;
 
   void Destroy(JNIEnv* env, jobject obj);
-  void SurfaceCreated(JNIEnv* env, jobject obj, jobject jsurface);
+  void SurfaceCreated(JNIEnv* env,
+                      jobject obj,
+                      jobject jsurface,
+                      float device_pixel_ratio);
   void SurfaceDestroyed(JNIEnv* env, jobject obj);
   void SurfaceSetSize(JNIEnv* env,
                       jobject obj,

components/native_viewport/platform_viewport_headless.cc

@@ -17,6 +17,7 @@ PlatformViewportHeadless::~PlatformViewportHeadless() {
 
 void PlatformViewportHeadless::Init(const gfx::Rect& bounds) {
   metrics_ = mojo::ViewportMetrics::New();
+  metrics_->device_pixel_ratio = 1.f;
   metrics_->size = mojo::Size::From(bounds.size());
 }
 

components/native_viewport/platform_viewport_win.cc

@@ -40,6 +40,8 @@ class PlatformViewportWin : public PlatformViewport,
   // Overridden from PlatformViewport:
   void Init(const gfx::Rect& bounds) override {
     metrics_ = mojo::ViewportMetrics::New();
+    // TODO(sky): make density real.
+    metrics_->device_pixel_ratio = 1.f;
     metrics_->size = mojo::Size::From(bounds.size());
     platform_window_.reset(new ui::WinWindow(this, bounds));
   }
@@ -117,7 +119,8 @@ class PlatformViewportWin : public PlatformViewport,
 
   void OnAcceleratedWidgetAvailable(
       gfx::AcceleratedWidget widget) override {
-    delegate_->OnAcceleratedWidgetAvailable(widget);
+    delegate_->OnAcceleratedWidgetAvailable(widget,
+                                            metrics_->device_pixel_ratio);
   }
 
   void OnActivationChanged(bool active) override {}

components/native_viewport/platform_viewport_x11.cc

@@ -51,6 +51,8 @@ class PlatformViewportX11 : public PlatformViewport,
     event_source_ = ui::PlatformEventSource::CreateDefault();
 
     metrics_ = mojo::ViewportMetrics::New();
+    // TODO(sky): make density real.
+    metrics_->device_pixel_ratio = 1.f;
     metrics_->size = mojo::Size::From(bounds.size());
 
     platform_window_.reset(new ui::X11Window(this));
@@ -146,7 +148,8 @@ class PlatformViewportX11 : public PlatformViewport,
   void OnLostCapture() override {}
 
   void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget) override {
-    delegate_->OnAcceleratedWidgetAvailable(widget);
+    delegate_->OnAcceleratedWidgetAvailable(widget,
+                                            metrics_->device_pixel_ratio);
   }
 
   void OnActivationChanged(bool active) override {}

components/native_viewport/public/interfaces/native_viewport.mojom

@@ -10,7 +10,8 @@ import "ui/mojo/events/input_events.mojom";
 
 struct ViewportMetrics {
   Size size;
-  float device_pixel_ratio = 1.0;
+  // A value of 0 indicates the real value is not yet available.
+  float device_pixel_ratio = 0.0;
 };
 
 interface NativeViewport {

components/view_manager/public/cpp/view_observer.h

@@ -54,10 +54,10 @@ class ViewObserver {
                                    const Rect& old_bounds,
                                    const Rect& new_bounds) {}
 
-  virtual void OnViewViewportMetricsChanged(View* view,
-                                            const ViewportMetrics& old_bounds,
-                                            const ViewportMetrics& new_bounds) {
-  }
+  virtual void OnViewViewportMetricsChanged(
+      View* view,
+      const ViewportMetrics& old_metrics,
+      const ViewportMetrics& new_metrics) {}
 
   virtual void OnViewFocusChanged(View* gained_focus, View* lost_focus) {}