Add DeviceDisplayInfo getter in WindowAndroid.

content/browser/renderer_host/render_widget_host_view_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 #include <utility>
 
 #include "base/android/build_info.h"
@@ skipping 101 matching lines @@
   surface->AddDestructionDependency(sequence);
 }
 
 const int kUndefinedOutputSurfaceId = -1;
 
 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
 
 class GLHelperHolder
     : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  public:
-  static GLHelperHolder* Create();
+  static GLHelperHolder* Create(size_t display_area);
   ~GLHelperHolder() override;
 
-  void Initialize();
+  void Initialize(size_t display_area);
 
   // WebGraphicsContextLostCallback implementation.
   void onContextLost() override;
 
   GLHelper* GetGLHelper() { return gl_helper_.get(); }
   bool IsLost() { return !context_.get() || context_->isContextLost(); }
 
  private:
   GLHelperHolder();
-  static scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateContext3D();
+  static scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateContext3D(
+      size_t display_area);
 
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context_;
   scoped_ptr<GLHelper> gl_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(GLHelperHolder);
 };
 
-GLHelperHolder* GLHelperHolder::Create() {
+GLHelperHolder* GLHelperHolder::Create(size_t display_area) {
   GLHelperHolder* holder = new GLHelperHolder;
-  holder->Initialize();
+  holder->Initialize(display_area);
 
   return holder;
 }
 
 GLHelperHolder::GLHelperHolder() {
 }
 
 GLHelperHolder::~GLHelperHolder() {
 }
 
-void GLHelperHolder::Initialize() {
-  context_ = CreateContext3D();
+void GLHelperHolder::Initialize(size_t display_area) {
+  context_ = CreateContext3D(display_area);
   if (context_) {
     context_->setContextLostCallback(this);
     gl_helper_.reset(new GLHelper(context_->GetImplementation(),
                                   context_->GetContextSupport()));
   }
 }
 
 void GLHelperHolder::onContextLost() {
   // Need to post a task because the command buffer client cannot be deleted
   // from within this callback.
   LOG(ERROR) << "Context lost.";
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RenderWidgetHostViewAndroid::OnContextLost));
 }
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
-GLHelperHolder::CreateContext3D() {
+GLHelperHolder::CreateContext3D(size_t display_area) {
   BrowserGpuChannelHostFactory* factory =
       BrowserGpuChannelHostFactory::instance();
   scoped_refptr<GpuChannelHost> gpu_channel_host(factory->GetGpuChannel());
   // GLHelper can only be used in asynchronous APIs for postprocessing after
   // Browser Compositor operations (i.e. readback).
   if (!gpu_channel_host.get()) {
     // The Browser Compositor is in charge of reestablishing the channel.
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   }
 
   blink::WebGraphicsContext3D::Attributes attrs;
   attrs.shareResources = true;
   GURL url("chrome://gpu/RenderWidgetHostViewAndroid");
   static const size_t kBytesPerPixel = 4;
-  gfx::DeviceDisplayInfo display_info;
-  size_t full_screen_texture_size_in_bytes = display_info.GetDisplayHeight() *
-                                             display_info.GetDisplayWidth() *
-                                             kBytesPerPixel;
+  size_t full_screen_texture_size_in_bytes = display_area * kBytesPerPixel;
   WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
   limits.command_buffer_size = 64 * 1024;
   limits.start_transfer_buffer_size = 64 * 1024;
   limits.min_transfer_buffer_size = 64 * 1024;
   limits.max_transfer_buffer_size = std::min(
       3 * full_screen_texture_size_in_bytes, kDefaultMaxTransferBufferSize);
   limits.mapped_memory_reclaim_limit =
       WebGraphicsContext3DCommandBufferImpl::kNoLimit;
   bool lose_context_when_out_of_memory = false;
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
       new WebGraphicsContext3DCommandBufferImpl(
           0,  // offscreen
           url, gpu_channel_host.get(), attrs, lose_context_when_out_of_memory,
           limits, nullptr));
   context->SetContextType(BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
   if (context->InitializeOnCurrentThread()) {
     context->traceBeginCHROMIUM(
         "gpu_toplevel",
         base::StringPrintf("CmdBufferImageTransportFactory-%p",
                            context.get()).c_str());
   } else {
     context.reset();
   }
 
   return context;
 }
 
 // This can only be used for readback postprocessing. It may return null if the
 // channel was lost and not reestablished yet.
-GLHelper* GetPostReadbackGLHelper() {
+GLHelper* GetPostReadbackGLHelper(size_t display_area) {
   static GLHelperHolder* g_readback_helper_holder = nullptr;
 
   if (g_readback_helper_holder && g_readback_helper_holder->IsLost()) {
     delete g_readback_helper_holder;
     g_readback_helper_holder = nullptr;
   }
 
   if (!g_readback_helper_holder)
-    g_readback_helper_holder = GLHelperHolder::Create();
+    g_readback_helper_holder = GLHelperHolder::Create(display_area);
 
   return g_readback_helper_holder->GetGLHelper();
 }
 
 void CopyFromCompositingSurfaceFinished(
     const ReadbackRequestCallback& callback,
     scoped_ptr<cc::SingleReleaseCallback> release_callback,
     scoped_ptr<SkBitmap> bitmap,
     const base::TimeTicks& start_time,
     scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock,
+    size_t display_area,
     bool result) {
   TRACE_EVENT0(
       "cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceFinished");
   bitmap_pixels_lock.reset();
   gpu::SyncToken sync_token;
   if (result) {
-    GLHelper* gl_helper = GetPostReadbackGLHelper();
+    GLHelper* gl_helper = GetPostReadbackGLHelper(display_area);
     if (gl_helper)
       gl_helper->GenerateSyncToken(&sync_token);
   }
   const bool lost_resource = !sync_token.HasData();
   release_callback->Run(sync_token, lost_resource);
   UMA_HISTOGRAM_TIMES(kAsyncReadBackString,
                       base::TimeTicks::Now() - start_time);
   ReadbackResponse response = result ? READBACK_SUCCESS : READBACK_FAILED;
   callback.Run(*bitmap, response);
 }
@@ skipping 25 matching lines @@
 gfx::RectF GetSelectionRect(const ui::TouchSelectionController& controller) {
   gfx::RectF rect = controller.GetRectBetweenBounds();
   if (rect.IsEmpty())
     return rect;
 
   rect.Union(controller.GetStartHandleRect());
   rect.Union(controller.GetEndHandleRect());
   return rect;
 }
 
+void DisplayInfoToScreenInfo(const gfx::Display& display,
+                             const gfx::DeviceDisplayInfo& info,
+                             blink::WebScreenInfo* results) {
+  results->rect = display.bounds();
+  // TODO(husky): Remove any system controls from availableRect.
+  results->availableRect = display.work_area();
+  results->deviceScaleFactor = display.device_scale_factor();
+  results->orientationAngle = display.RotationAsDegree();
+  results->orientationType =
+      RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
+  results->depth = info.GetBitsPerPixel();
+  results->depthPerComponent = info.GetBitsPerComponent();
+  results->isMonochrome = (results->depthPerComponent == 0);
+}
+
 }  // anonymous namespace
 
 RenderWidgetHostViewAndroid::LastFrameInfo::LastFrameInfo(
     uint32_t output_id,
     scoped_ptr<cc::CompositorFrame> output_frame)
     : output_surface_id(output_id), frame(std::move(output_frame)) {}
 
 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {}
 
 void RenderWidgetHostViewAndroid::OnContextLost() {
@@ skipping 594 matching lines @@
   }
   ui::WindowAndroidCompositor* compositor =
       content_view_core_->GetWindowAndroid()->GetCompositor();
   DCHECK(compositor);
   DCHECK(!surface_id_.is_null());
   scoped_refptr<cc::Layer> layer = CreateDelegatedLayer();
   DCHECK(layer);
   layer->SetHideLayerAndSubtree(true);
   compositor->AttachLayerForReadback(layer);
 
+  const gfx::DeviceDisplayInfo& display_info =
+      content_view_core_->GetWindowAndroid()->GetDeviceDisplayInfo();
+  size_t display_area =
+      display_info.GetDisplayHeight() * display_info.GetDisplayWidth();
+
   readback_layer = layer;
   request = cc::CopyOutputRequest::CreateRequest(
       base::Bind(&RenderWidgetHostViewAndroid::
                      PrepareTextureCopyOutputResultForDelegatedReadback,
                  dst_size_in_pixel, preferred_color_type, start_time,
-                 readback_layer, callback));
+                 readback_layer, callback, display_area));
   if (!src_subrect_in_pixel.IsEmpty())
     request->set_area(src_subrect_in_pixel);
   readback_layer->RequestCopyOfOutput(std::move(request));
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceToVideoFrame(
     const gfx::Rect& src_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(const gfx::Rect&, bool)>& callback) {
   NOTIMPLEMENTED();
@@ skipping 582 matching lines @@
     DestroyDelegatedContent();
   frame_evictor_->DiscardedFrame();
 }
 
 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
     const gfx::Size& desired_size) {
   NOTREACHED();
   return false;
 }
 
-void RenderWidgetHostViewAndroid::GetScreenInfo(blink::WebScreenInfo* result) {
-  // ScreenInfo isn't tied to the widget on Android. Always return the default.
-  RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
+void RenderWidgetHostViewAndroid::GetScreenInfo(blink::WebScreenInfo* results) {
+  if (content_view_core_) {

[no sievers, 2016/02/27 01:11:52]

I'm wondering if it's worth plumbing all this info through all the static
functions and callbacks here, because... well it's all static... so if there are
multiple displays somebody is using the wrong dimensions.

We also don't want to create a context per display just for this.
Maybe just keep going with GetDefaultScreenInfo() here?

We can discuss separately what this really affects and how in a multi-screen
world. I think it's just the UI resource uploads. (And maybe '*3' above is even
a bit high'.

[boliu, 2016/02/27 01:30:56]

It's also used to determine stuff like screen density.
I assume you mean CreateContext3D? I don't see how this CL creates more
Context3D now? The work is to add multi display support for android webview, not
chrome..

[no sievers, 2016/02/29 18:16:03]

The point was: If this is for multi-display, then there's no need to plumb this
through to the static shared context (and I don't think we want to create one
context per display either). And I'd just leave this file untouched as far as
possible and use the default screen info as before.

[gsennton, 2016/04/25 18:55:58]

I experimented a bit by setting different device scale factors at different
points in the code and it seems the main point which actually makes a WebView on
a Presentation, targeting a virtual display, look OK is
RenderWidgetHostViewAndroid::GetScreenInfo (i.e. if I hardcode the scale factor
in GetDefaultScreenInfo to be that of the primary display, even if all other
locations use the correct value - the scale factor for the virtual display -
then we display content in an incorrect way). :/

+    gfx::NativeView view_android = GetNativeView();
+
+    const gfx::Display& display =
+        gfx::Screen::GetScreen()->GetDisplayNearestWindow(view_android);
+    const gfx::DeviceDisplayInfo& info =
+        content_view_core_->GetWindowAndroid()->GetDeviceDisplayInfo();
+    DisplayInfoToScreenInfo(display, info, results);
+  } else {
+    GetDefaultScreenInfo(results);
+  }
 }
 
 bool RenderWidgetHostViewAndroid::GetScreenColorProfile(
     std::vector<char>* color_profile) {
   DCHECK(color_profile->empty());
   NOTREACHED();
   return false;
 }
 
 // TODO(jrg): Find out the implications and answer correctly here,
@@ skipping 401 matching lines @@
 }
 
 // static
 void RenderWidgetHostViewAndroid::
     PrepareTextureCopyOutputResultForDelegatedReadback(
         const gfx::Size& dst_size_in_pixel,
         SkColorType color_type,
         const base::TimeTicks& start_time,
         scoped_refptr<cc::Layer> readback_layer,
         const ReadbackRequestCallback& callback,
+        size_t display_area,
         scoped_ptr<cc::CopyOutputResult> result) {
   readback_layer->RemoveFromParent();
   PrepareTextureCopyOutputResult(dst_size_in_pixel, color_type, start_time,
-                                 callback, std::move(result));
+                                 callback, display_area, std::move(result));
 }
 
 // TODO(wjmaclean): There is significant overlap between
 // PrepareTextureCopyOutputResult and CopyFromCompositingSurfaceFinished in
 // this file, and the versions in surface_utils.cc. They should
 // be merged. See https://crbug.com/582955
 
 // static
 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     SkColorType color_type,
     const base::TimeTicks& start_time,
     const ReadbackRequestCallback& callback,
+    size_t display_area,
     scoped_ptr<cc::CopyOutputResult> result) {
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, SkBitmap(), READBACK_FAILED));
   TRACE_EVENT0("cc",
                "RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult");
 
   if (!result->HasTexture() || result->IsEmpty() || result->size().IsEmpty())
     return;
 
   gfx::Size output_size_in_pixel;
   if (dst_size_in_pixel.IsEmpty())
     output_size_in_pixel = result->size();
   else
     output_size_in_pixel = dst_size_in_pixel;
 
-  GLHelper* gl_helper = GetPostReadbackGLHelper();
+  GLHelper* gl_helper = GetPostReadbackGLHelper(display_area);
   if (!gl_helper)
     return;
   if (!gl_helper->IsReadbackConfigSupported(color_type))
     color_type = kRGBA_8888_SkColorType;
   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
   if (!bitmap->tryAllocPixels(SkImageInfo::Make(output_size_in_pixel.width(),
                                                 output_size_in_pixel.height(),
                                                 color_type,
                                                 kOpaque_SkAlphaType))) {
     scoped_callback_runner.Reset(
@@ skipping 13 matching lines @@
   if (!texture_mailbox.IsTexture())
     return;
 
   ignore_result(scoped_callback_runner.Release());
 
   gl_helper->CropScaleReadbackAndCleanMailbox(
       texture_mailbox.mailbox(), texture_mailbox.sync_token(), result->size(),
       gfx::Rect(result->size()), output_size_in_pixel, pixels, color_type,
       base::Bind(&CopyFromCompositingSurfaceFinished, callback,
                  base::Passed(&release_callback), base::Passed(&bitmap),
-                 start_time, base::Passed(&bitmap_pixels_lock)),
+                 start_time, base::Passed(&bitmap_pixels_lock), display_area),
       GLHelper::SCALER_QUALITY_GOOD);
 }
 
 void RenderWidgetHostViewAndroid::OnStylusSelectBegin(float x0,
                                                       float y0,
                                                       float x1,
                                                       float y1) {
   SelectBetweenCoordinates(gfx::PointF(x0, y0), gfx::PointF(x1, y1));
 }
 
@@ skipping 14 matching lines @@
   blink::WebGestureEvent long_press = WebGestureEventBuilder::Build(
       blink::WebInputEvent::GestureLongPress,
       (time - base::TimeTicks()).InSecondsF(), x, y);
   SendGestureEvent(long_press);
 }
 
 // static
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(
     blink::WebScreenInfo* results) {
   const gfx::Display& display = gfx::Screen::GetScreen()->GetPrimaryDisplay();
-  results->rect = display.bounds();
-  // TODO(husky): Remove any system controls from availableRect.
-  results->availableRect = display.work_area();
-  results->deviceScaleFactor = display.device_scale_factor();
-  results->orientationAngle = display.RotationAsDegree();
-  results->orientationType =
-      RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
-  results->depth = info.GetBitsPerPixel();
-  results->depthPerComponent = info.GetBitsPerComponent();
-  results->isMonochrome = (results->depthPerComponent == 0);
+  DisplayInfoToScreenInfo(display, info, results);
 }
 
 }  // namespace content