Wires through scale factor and bounds in html_viewer

mojo/services/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 "mojo/services/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"
@@ skipping 23 matching lines @@
 #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/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/mojo_services/src/surfaces/public/interfaces/surfaces.mojom.h"
 #include "third_party/mojo_services/src/view_manager/public/cpp/view.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/size_conversions.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 74 matching lines @@
 }
 
 void HTMLDocument::OnEmbed(
     View* root,
     mojo::InterfaceRequest<mojo::ServiceProvider> services,
     mojo::ServiceProviderPtr exposed_services) {
   DCHECK(!is_headless_);
   root_ = root;
   embedder_service_provider_ = exposed_services.Pass();
   navigator_host_.set_service_provider(embedder_service_provider_.get());
-
-  blink::WebSize root_size(root_->bounds().width, root_->bounds().height);
-  web_view_->resize(root_size);
-  web_layer_tree_view_impl_->setViewportSize(root_size);
+  UpdateWebviewSizeFromViewSize();
   web_layer_tree_view_impl_->set_view(root_);
   root_->AddObserver(this);
 }
 
 void HTMLDocument::Create(mojo::ApplicationConnection* connection,
                           mojo::InterfaceRequest<AxProvider> request) {
   if (!web_view_)
     return;
   ax_provider_impls_.insert(
       WeakBindToRequest(new AxProviderImpl(web_view_), &request));
@@ skipping 15 matching lines @@
   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);
 }
 
+void HTMLDocument::UpdateWebviewSizeFromViewSize() {
+  web_view_->setDeviceScaleFactor(root_->viewport_metrics().device_pixel_ratio);
+  const gfx::Size size_in_pixels(root_->bounds().width, root_->bounds().height);
+  // TODO: WebView should really take pixels (or float) so it has the real size.

[jamesr, 2015/03/16 23:26:45]

you're picking the real size here. Blink operates in an integer number of DIPs
and it's up to the embedder (HTMLDocument in this case) to figure out what that
should be.  That won't always map to an integer number of physical pixels, which
is why the embedder has to decide what it wants. It doesn't make any sense for
Blink to take a float or physical pixel number.

ceiled is a bit iffy since it means that the part of the content that doesn't
fit inside the physical bounds will be cut off. i.e. if the DSF is 1.5 and the
physical size is 10x10 this will compute a dip size of ceil(10 * 1/1.5) =
ceil(6.6667) = 7, but the last third of the dip will be cut off assuming that
this view starts on an exact physical pixel boundary.  i think you want to do
something like compute the largest fully enclosed DIP rectangle within this
view's bounds

[sky, 2015/03/16 23:33:00]

But if I do 6, then we're not rendering the last pixel, right?

Seems like there are only two options: don't render some amount of pixels on the
right side, or render past the size. I'm favoring rendering past the size so we
don't get some amount of pixels that don't match the web content on the right
side.

+  const gfx::Size size_in_dips = gfx::ToCeiledSize(gfx::ScaleSize(
+      size_in_pixels, 1 / root_->viewport_metrics().device_pixel_ratio));
+  web_view_->resize(
+      blink::WebSize(size_in_dips.width(), size_in_dips.height()));
+  web_layer_tree_view_impl_->setViewportSize(size_in_pixels);
+}
+
 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));
     return;
   }
@@ skipping 107 matching lines @@
         make_scoped_ptr(new media::DefaultCdmFactory()),
         media_permission_.get()));
   }
   return web_encrypted_media_client_.get();
 }
 
 void HTMLDocument::OnViewBoundsChanged(View* view,
                                        const Rect& old_bounds,
                                        const Rect& new_bounds) {
   DCHECK_EQ(view, root_);
-  web_view_->resize(
-      blink::WebSize(view->bounds().width, view->bounds().height));
+  UpdateWebviewSizeFromViewSize();
 }
 
 void HTMLDocument::OnViewDestroyed(View* view) {
   DCHECK_EQ(view, root_);
   root_ = nullptr;
 }
 
 void HTMLDocument::OnViewInputEvent(View* view, const mojo::EventPtr& event) {
   scoped_ptr<blink::WebInputEvent> web_event =
       event.To<scoped_ptr<blink::WebInputEvent>>();
   if (web_event)
     web_view_->handleInputEvent(*web_event);
 }
 
 }  // namespace html_viewer