Clobber frame_data->device_scale_factor to 1 on Android.

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/sys_utils.h"
 #include "base/basictypes.h"
@@ skipping 674 matching lines @@
   ui::WindowAndroidCompositor* compositor =
       content_view_core_->GetWindowAndroid()->GetCompositor();
   DCHECK(compositor);
   DCHECK(frame_provider_);
   scoped_refptr<cc::DelegatedRendererLayer> delegated_layer =
       cc::DelegatedRendererLayer::Create(frame_provider_);
   delegated_layer->SetBounds(content_size_in_layer_);
   delegated_layer->SetHideLayerAndSubtree(true);
   delegated_layer->SetIsDrawable(true);
   delegated_layer->SetContentsOpaque(true);
   gfx::Transform layer_scale(

[jamesr, 2014/06/12 23:00:04]

you probably want to undo this change as well, right?

[aelias_OOO_until_Jul13, 2014/06/13 00:17:46]

No, since https://codereview.chromium.org/331453004 didn't land, this is old
code that still works.

[jamesr, 2014/06/13 00:27:53]

Not that old - I added this scale 2 days ago.

[aelias_OOO_until_Jul13, 2014/06/13 00:36:07]

Ah I see, removed.

       device_scale_factor, 0.f, 0.f, device_scale_factor, 0.f, 0.f);
   delegated_layer->SetTransform(layer_scale);
   compositor->AttachLayerForReadback(delegated_layer);
 
   readback_layer = delegated_layer;
   request = cc::CopyOutputRequest::CreateRequest(
       base::Bind(&RenderWidgetHostViewAndroid::
                      PrepareTextureCopyOutputResultForDelegatedReadback,
                  dst_size_in_pixel,
                  bitmap_config,
@@ skipping 81 matching lines @@
       resource_collection_->SetClient(NULL);
       if (resource_collection_->LoseAllResources())
         SendReturnedDelegatedResources(last_output_surface_id_);
       resource_collection_ = NULL;
     }
     DestroyDelegatedContent();
 
     last_output_surface_id_ = output_surface_id;
   }
 
+  // DelegatedRendererLayerImpl applies the inverse device_scale_factor of the
+  // renderer frame, assuming that the browser compositor will scale
+  // it back up to device scale.  But on Android we put our browser layers in
+  // physical pixels and set our browser CC device_scale_factor to 1, so this
+  // suppresses the transform.

[jamesr, 2014/06/12 23:00:04]

maybe include a link to the crbug about multiple monitor support on Android
since whoever ends up working on that bug is going to run into this?

[aelias_OOO_until_Jul13, 2014/06/13 00:17:46]

crbug archeology didn't turn up anything, but I linked newly filed bug
http://crbug.com/384134

[jamesr, 2014/06/13 00:27:53]

I was thinking of http://code.google.com/p/chromium/issues/detail?id=310763

[aelias_OOO_until_Jul13, 2014/06/13 00:36:07]

OK, linked.

+  frame_data->device_scale_factor = 1.0f;
+
   if (!has_content) {
     DestroyDelegatedContent();
   } else {
     if (!resource_collection_.get()) {
       resource_collection_ = new cc::DelegatedFrameResourceCollection;
       resource_collection_->SetClient(this);
     }
     if (!frame_provider_ ||
         texture_size_in_layer_ != frame_provider_->frame_size()) {
       RemoveLayers();
       frame_provider_ = new cc::DelegatedFrameProvider(
           resource_collection_.get(), frame_data.Pass());
       layer_ = cc::DelegatedRendererLayer::Create(frame_provider_);
       AttachLayers();
     } else {
       frame_provider_->SetFrameData(frame_data.Pass());
     }
   }
 
   if (layer_.get()) {
     layer_->SetIsDrawable(true);
     layer_->SetContentsOpaque(true);
     layer_->SetBounds(content_size_in_layer_);
     layer_->SetNeedsDisplay();
-    // DelegatedRendererLayer scales the frame data from physical space to DIPs
-    // by inverting the frame's device scale factor, assuming that the browser
-    // compositor will map from DIPs back to physical pixels using its own
-    // device scale factor. However, the Android browser compositor always uses
-    // a device scale factor of 1.0, so we have to transform the delegated
-    // layer by the device scale to get it into the same physical pixel space as
-    // the rest of the UI.
-    const gfx::Display& display =
-        gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
-    float device_scale_factor = display.device_scale_factor();
-    gfx::Transform layer_scale(
-        device_scale_factor, 0.f, 0.f, device_scale_factor, 0.f, 0.f);
-    layer_->SetTransform(layer_scale);
   }
 
   base::Closure ack_callback =
       base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
                  weak_ptr_factory_.GetWeakPtr(),
                  output_surface_id);
 
   ack_callbacks_.push(ack_callback);
   if (host_->is_hidden())
     RunAckCallbacks();
@@ skipping 605 matching lines @@
   results->availableRect = display.work_area();
   results->deviceScaleFactor = display.device_scale_factor();
   results->orientationAngle = display.RotationAsDegree();
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content