Make WebView work for external displays (over Presentations).

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 106 matching lines @@
 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
 
 // Sends an acknowledgement to the renderer of a processed IME event.
 void SendImeEventAck(RenderWidgetHostImpl* host) {
   host->Send(new ViewMsg_ImeEventAck(host->GetRoutingID()));
 }
 
 class GLHelperHolder
     : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  public:
-  static GLHelperHolder* Create();
+  static GLHelperHolder* Create(gfx::NativeWindow nativeWindow);
   ~GLHelperHolder() override;
 
-  void Initialize();
+  void Initialize(gfx::NativeWindow nativeWindow);
 
   // 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 nativeWindow);
 
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context_;
   scoped_ptr<GLHelper> gl_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(GLHelperHolder);
 };
 
-GLHelperHolder* GLHelperHolder::Create() {
+GLHelperHolder* GLHelperHolder::Create(gfx::NativeWindow nativeWindow) {
   GLHelperHolder* holder = new GLHelperHolder;
-  holder->Initialize();
+  holder->Initialize(nativeWindow);
 
   return holder;
 }
 
 GLHelperHolder::GLHelperHolder() {
 }
 
 GLHelperHolder::~GLHelperHolder() {
 }
 
-void GLHelperHolder::Initialize() {
-  context_ = CreateContext3D();
+void GLHelperHolder::Initialize(gfx::NativeWindow nativeWindow) {
+  context_ = CreateContext3D(nativeWindow);
   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 nativeWindow) {
   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;
+  gfx::DeviceDisplayInfo display_info(nativeWindow->GetJavaObject().obj());
   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 11 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 nativeWindow) {
   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(nativeWindow);
 
   return g_readback_helper_holder->GetGLHelper();
 }
 
 void CopyFromCompositingSurfaceFinished(
     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 nativeWindow,
     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(nativeWindow);
     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 677 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 958 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,
         ReadbackRequestCallback& callback,
+        gfx::NativeWindow nativeWindow,
         scoped_ptr<cc::CopyOutputResult> result) {
   readback_layer->RemoveFromParent();
   PrepareTextureCopyOutputResult(
-      dst_size_in_pixel, color_type, start_time, callback, result.Pass());
+      dst_size_in_pixel, color_type, start_time, callback, nativeWindow,
+      result.Pass());
 }
 
 // static
 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     SkColorType color_type,
     const base::TimeTicks& start_time,
     ReadbackRequestCallback& callback,
+    gfx::NativeWindow nativeWindow,
     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(nativeWindow);
   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 21 matching lines @@
       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)),
+                 base::Passed(&bitmap_pixels_lock),
+                 nativeWindow),
       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 22 matching lines @@
     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;
+  gfx::DeviceDisplayInfo info; // TODO since we don't have a Native Window here
+  // we can only use the primary display?

[boliu, 2015/06/01 15:30:18]

Yes

Although should double check that any caller of this should be updated to use
WindowAndroid instead

[gsennton, 2015/06/04 14:10:29]

This is called from two places:

1. GetScreenInfo in this same class:
void RenderWidgetHostViewAndroid::GetScreenInfo(blink::WebScreenInfo* result) {
  // ScreenInfo isn't tied to the widget on Android. Always return the default.
  RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
}
I am not sure about the comment here about ScreenInfo not being tied to the
widget -- we do have a WindowAndroid: content_view_core_window_android_ which
probably should be used here? (though we would need to create a gfx::Display
from a WindowAndroid/DeviceDisplayInfo similar to how it is currently done in
screen_android)

2.
void RenderWidgetHostImpl::GetWebScreenInfo(blink::WebScreenInfo* result) {
  if (view_)
    view_->GetScreenInfo(result);
  else
    RenderWidgetHostViewBase::GetDefaultScreenInfo(result);
  ...
}
this should be fine if we fix nr.1?

[boliu, 2015/06/05 04:57:51]

You are right. Comment assumes android only has a single screen, so comment is
wrong.
Yep

   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content