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 "base/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 102 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(gfx::NativeWindow native_window);
   ~GLHelperHolder() override;
 
-  void Initialize();
+  void Initialize(gfx::NativeWindow native_window);
 
   // 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(
+      gfx::NativeWindow native_window);
 
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context_;
   scoped_ptr<GLHelper> gl_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(GLHelperHolder);
 };
 
-GLHelperHolder* GLHelperHolder::Create() {
+GLHelperHolder* GLHelperHolder::Create(gfx::NativeWindow native_window) {
   GLHelperHolder* holder = new GLHelperHolder;
-  holder->Initialize();
+  holder->Initialize(native_window);
 
   return holder;
 }
 
 GLHelperHolder::GLHelperHolder() {
 }
 
 GLHelperHolder::~GLHelperHolder() {
 }
 
-void GLHelperHolder::Initialize() {
-  context_ = CreateContext3D();
+void GLHelperHolder::Initialize(gfx::NativeWindow native_window) {
+  context_ = CreateContext3D(native_window);
   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(gfx::NativeWindow native_window) {
   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;
+  const gfx::DeviceDisplayInfo& display_info =
+      native_window->GetDeviceDisplayInfo();
   size_t full_screen_texture_size_in_bytes = display_info.GetDisplayHeight() *
                                              display_info.GetDisplayWidth() *
                                              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 =
@@ skipping 12 matching lines @@
                            context.get()).c_str());
   } else {
     context.reset();
   }
 
   return context.Pass();
 }
 
 // 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(gfx::NativeWindow native_window) {
   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(native_window);
 
   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,
+    gfx::NativeWindow native_window,
     bool result) {
   TRACE_EVENT0(
       "cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceFinished");
   bitmap_pixels_lock.reset();
   uint32 sync_point = 0;
   if (result) {
-    GLHelper* gl_helper = GetPostReadbackGLHelper();
+    GLHelper* gl_helper = GetPostReadbackGLHelper(native_window);
     if (gl_helper)
       sync_point = gl_helper->InsertSyncPoint();
   }
   bool lost_resource = sync_point == 0;
   release_callback->Run(sync_point, 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 output_id,
     scoped_ptr<cc::CompositorFrame> output_frame)
     : output_surface_id(output_id), frame(output_frame.Pass()) {}
 
 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {}
 
 void RenderWidgetHostViewAndroid::OnContextLost() {
@@ skipping 595 matching lines @@
   scoped_refptr<cc::Layer> layer = CreateDelegatedLayer();
   DCHECK(layer);
   layer->SetHideLayerAndSubtree(true);
   compositor->AttachLayerForReadback(layer);
 
   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, content_view_core_window_android_));
   if (!src_subrect_in_pixel.IsEmpty())
     request->set_area(src_subrect_in_pixel);
   readback_layer->RequestCopyOfOutput(request.Pass());
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) {
   NOTIMPLEMENTED();
@@ skipping 617 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_) {
+    gfx::NativeView view_android = GetNativeView();
+
+    const gfx::Display& display =
+        gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(view_android);
+    const gfx::DeviceDisplayInfo& info =
+        content_view_core_window_android_->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 364 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,
+        gfx::NativeWindow native_window,
         scoped_ptr<cc::CopyOutputResult> result) {
   readback_layer->RemoveFromParent();
-  PrepareTextureCopyOutputResult(
-      dst_size_in_pixel, color_type, start_time, callback, result.Pass());
+  PrepareTextureCopyOutputResult(dst_size_in_pixel, color_type, start_time,
+                                 callback, native_window, result.Pass());
 }
 
 // static
 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     SkColorType color_type,
     const base::TimeTicks& start_time,
     const ReadbackRequestCallback& callback,
+    gfx::NativeWindow native_window,
     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(native_window);
   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(
         base::Bind(callback, SkBitmap(), READBACK_BITMAP_ALLOCATION_FAILURE));
     return;
   }
 
 
   scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock(
       new SkAutoLockPixels(*bitmap));
   uint8* pixels = static_cast<uint8*>(bitmap->getPixels());
 
   cc::TextureMailbox texture_mailbox;
   scoped_ptr<cc::SingleReleaseCallback> release_callback;
   result->TakeTexture(&texture_mailbox, &release_callback);
   DCHECK(texture_mailbox.IsTexture());
   if (!texture_mailbox.IsTexture())
     return;
 
   ignore_result(scoped_callback_runner.Release());
 
   gl_helper->CropScaleReadbackAndCleanMailbox(
-      texture_mailbox.mailbox(),
-      texture_mailbox.sync_point(),
-      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)),
+      texture_mailbox.mailbox(), texture_mailbox.sync_point(), 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), native_window),

[jdduke (slow), 2015/10/22 15:37:05]

sievers@ is it safe to bind this pointer? I know WindowAndroid should outlast
most things, but we've had some related lifetime issues in the past...

If all that is really needed here is to get the display dimensions
(width+height), any reason we shouldn't pass that in directly?

[no sievers, 2015/10/26 20:42:25]

No this is actually not safe, since the pointer is mutable.

We recently discussed the supported or expected use cases for
SetContentViewCore() in https://codereview.chromium.org/1385543003/#msg20. And
that it would be good to document that implicitly or explicitly, so this would
be useful here now. (TLDR: we support detach from CVC, possibly deferred attach,
but not attaching to a different one after we're attached.)

We use the screen size to tweak the transfer buffer (shared memory size) when
creating the GL helper. So this patch actually only handles that to the extent
(same for compositor_impl_android.cc) that you create a compositor instance or
RWHV while the initial WindowAndroid is already on the external screen. For us
to be able to move it around screens more work is needed. You'd then also need
to update the shared memory limits on the fly (or tear down and create a new
context).

So if we moved to another screen, then either WindowAndroid would have to change
(then we can't store the pointer here), or the information it returns.

Really I think we should have an extra level of indirection where this class
stores a ViewAndroid that never changes and has a getter to get to the root
WindowAndroid. Then you can support detaching and even moving without having to
worry about it too much here, since you always use the getter to get to
WindowAndroid.

We probably want to deal with this incrementally. For this patch you can
probably just bind the display size (instead of the pointer) to avoid
use-after-free.

[gsennton, 2015/10/27 11:40:24]

Since all we need from the window_android pointer is the display area I've
updated the code so that it only passes the display area.

To make sure that I follow the discussion: why is it a problem that the pointer
is mutable?

Regarding moving screens, if I understand correctly WindowAndroid is basically a
wrapper around a Context, and a Context targets one single display so unless we
are reusing the same compositor/RWHV for several WindowAndroids targeting
different displays a moving of screens should never occur..?

       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 15 matching lines @@
       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::GetNativeScreen()->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