Makes the browser send pixels to the GPU process where it should

content/browser/renderer_host/render_widget_host_view_aura.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_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "content/browser/renderer_host/backing_store_skia.h"
+#include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/image_transport_client.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
@@ skipping 237 matching lines @@
 }
 
 void RenderWidgetHostViewAura::InitAsFullscreen(
     RenderWidgetHostView* reference_host_view) {
   is_fullscreen_ = true;
   window_->SetType(aura::client::WINDOW_TYPE_NORMAL);
   window_->Init(ui::LAYER_TEXTURED);
   window_->SetName("RenderWidgetHostViewAura");
   window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   window_->SetParent(NULL);
-  // Don't scale the canvas on high density screen because
+  // Don't scale the contents on high density screen because
   // the renderer takes care of it.
-  window_->layer()->set_scale_canvas(false);
+  window_->layer()->set_scale_content(false);
   Show();
   Focus();
 }
 
 RenderWidgetHost* RenderWidgetHostViewAura::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAura::DidBecomeSelected() {
   host_->WasRestored();
@@ skipping 160 matching lines @@
     base::Callback<void(bool)> callback) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
   ui::Compositor* compositor = GetCompositor();
   if (!compositor)
     return;
 
   ImageTransportClient* container = image_transport_clients_[current_surface_];
   if (!container)
     return;
 
-  if (!output->initialize(size.width(), size.height(), true))
+  gfx::Size size_in_pixel = content::ConvertSizeToPixel(this, size);
+  if (!output->initialize(
+      size_in_pixel.width(), size_in_pixel.height(), true))
     return;
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   content::GLHelper* gl_helper = factory->GetGLHelper(compositor);
   if (!gl_helper)
     return;
 
   unsigned char* addr = static_cast<unsigned char*>(
       output->getTopDevice()->accessBitmap(true).getPixels());
   scoped_callback_runner.Release();
   gl_helper->CopyTextureTo(container->texture_id(),
                            container->size(),
-                           size,
+                           size_in_pixel,
                            addr,
                            callback);
 }
 
 void RenderWidgetHostViewAura::OnAcceleratedCompositingStateChange() {
   // Delay UpdateExternalTexture until we actually got a software frame.
   // Sometimes (e.g. on a page load) the renderer will spuriously disable then
   // re-enable accelerated compositing, causing us to flash.
   // TODO(piman): factor the enable/disable accelerated compositing message into
   // the UpdateRect/AcceleratedSurfaceBuffersSwapped messages so that we have
   // fewer inconsistent temporary states.
   needs_update_texture_ = true;
+
+  // Don't scale contents on high density screen when content is accelerated
+  // because renderer takes care of it.
+  // TODO(pkotwicz): Implement DIP backing store such that renderer always
+  // scales web contents.
+  window_->layer()->set_scale_content(
+      !host_->is_accelerated_compositing_active());
 }
 
 void RenderWidgetHostViewAura::UpdateExternalTexture() {
   needs_update_texture_ = false;
   if (current_surface_ != 0 &&
       host_->is_accelerated_compositing_active()) {
 
     ImageTransportClient* container =
         image_transport_clients_[current_surface_];
     if (container)
       container->Update();
     window_->SetExternalTexture(container);
 
     if (!container) {
       resize_locks_.clear();
     } else {
       typedef std::vector<linked_ptr<ResizeLock> > ResizeLockList;
       ResizeLockList::iterator it = resize_locks_.begin();
       while (it != resize_locks_.end()) {
-        if ((*it)->expected_size() == container->size())
+        gfx::Size container_size = content::ConvertSizeToDIP(this,
+            container->size());
+        if ((*it)->expected_size() == container_size)
           break;
         ++it;
       }
       if (it != resize_locks_.end()) {
         ++it;
         ui::Compositor* compositor = GetCompositor();
         if (compositor) {
           // Delay the release of the lock until we've kicked a frame with the
           // new texture, to avoid resizing the UI before we have a chance to
           // draw a "good" frame.
@@ skipping 11 matching lines @@
         resize_locks_.erase(resize_locks_.begin(), it);
       }
     }
   } else {
     window_->SetExternalTexture(NULL);
     resize_locks_.clear();
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
-    const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
+    const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int gpu_host_id) {
-  current_surface_ = params.surface_handle;
+  current_surface_ = params_in_pixel.surface_handle;
   UpdateExternalTexture();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface.
     // Must still send the ACK.
-    RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
+    RenderWidgetHostImpl::AcknowledgeSwapBuffers(params_in_pixel.route_id,
+        gpu_host_id);
   } else {
-    gfx::Size surface_size =
-        image_transport_clients_[params.surface_handle]->size();
+    gfx::Size surface_size_in_pixel =
+        image_transport_clients_[params_in_pixel.surface_handle]->size();
+    gfx::Size surface_size = content::ConvertSizeToDIP(this,
+                                                       surface_size_in_pixel);
     window_->SchedulePaintInRect(gfx::Rect(surface_size));
 
     if (!resize_locks_.empty() && !compositor->DrawPending()) {
       // If we are waiting for the resize, fast-track the ACK.
       // However only do so if we're not between the Draw() and the
       // OnCompositingEnded(), because out-of-order execution in the GPU process
       // might corrupt the "front buffer" for the currently issued frame.
       RenderWidgetHostImpl::AcknowledgeSwapBuffers(
-          params.route_id, gpu_host_id);
+          params_in_pixel.route_id, gpu_host_id);
     } else {
       // Add sending an ACK to the list of things to do OnCompositingEnded
       on_compositing_ended_callbacks_.push_back(
           base::Bind(&RenderWidgetHostImpl::AcknowledgeSwapBuffers,
-                     params.route_id, gpu_host_id));
+                     params_in_pixel.route_id, gpu_host_id));
       if (!compositor->HasObserver(this))
         compositor->AddObserver(this);
     }
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
-    const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
+    const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
     int gpu_host_id) {
-  current_surface_ = params.surface_handle;
+  current_surface_ = params_in_pixel.surface_handle;
   UpdateExternalTexture();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface
     // Must still send the ACK
     RenderWidgetHostImpl::AcknowledgePostSubBuffer(
-        params.route_id, gpu_host_id);
+        params_in_pixel.route_id, gpu_host_id);
   } else {
-    gfx::Size surface_size =
-        image_transport_clients_[params.surface_handle]->size();
+    gfx::Size surface_size_in_pixel =
+        image_transport_clients_[params_in_pixel.surface_handle]->size();
 
     // Co-ordinates come in OpenGL co-ordinate space.
     // We need to convert to layer space.
-    window_->SchedulePaintInRect(gfx::Rect(
-        params.x,
-        surface_size.height() - params.y - params.height,
-        params.width,
-        params.height));
+    gfx::Rect rect_to_paint = content::ConvertRectToDIP(this, gfx::Rect(
+        params_in_pixel.x,
+        surface_size_in_pixel.height() - params_in_pixel.y -
+            params_in_pixel.height,
+        params_in_pixel.width,
+        params_in_pixel.height));
+    window_->SchedulePaintInRect(rect_to_paint);
 
     if (!resize_locks_.empty() && !compositor->DrawPending()) {
       // If we are waiting for the resize, fast-track the ACK.
       // However only do so if we're not between the Draw() and the
       // OnCompositingEnded(), because out-of-order execution in the GPU process
       // might corrupt the "front buffer" for the currently issued frame.
       RenderWidgetHostImpl::AcknowledgePostSubBuffer(
-          params.route_id, gpu_host_id);
+          params_in_pixel.route_id, gpu_host_id);
     } else {
       // Add sending an ACK to the list of things to do OnCompositingEnded
       on_compositing_ended_callbacks_.push_back(
           base::Bind(&RenderWidgetHostImpl::AcknowledgePostSubBuffer,
-                     params.route_id, gpu_host_id));
+                     params_in_pixel.route_id, gpu_host_id));
       if (!compositor->HasObserver(this))
         compositor->AddObserver(this);
     }
   }
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 bool RenderWidgetHostViewAura::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
   // Aura doesn't use GetBackingStore for accelerated pages, so it doesn't
   // matter what is returned here as GetBackingStore is the only caller of this
   // method. TODO(jbates) implement this if other Aura code needs it.
   return false;
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceNew(
-      int32 width,
-      int32 height,
+      int32 width_in_pixel,
+      int32 height_in_pixel,
       uint64* surface_handle,
       TransportDIB::Handle* shm_handle) {
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   scoped_refptr<ImageTransportClient> surface(factory->CreateTransportClient(
-        gfx::Size(width, height), surface_handle));
+        gfx::Size(width_in_pixel, height_in_pixel), surface_handle));
   if (!surface) {
     LOG(ERROR) << "Failed to create ImageTransportClient";
     return;
   }
   *shm_handle = surface->Handle();
 
   image_transport_clients_[*surface_handle] = surface;
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease(
@@ skipping 674 matching lines @@
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void content::RenderWidgetHostViewPort::GetDefaultScreenInfo(
     WebKit::WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }