Change the scale factor of texture_size from the layer's one to an estimation.

content/browser/renderer_host/image_transport_factory.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/image_transport_factory.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 61 matching lines @@
   }
 
   virtual GLHelper* GetGLHelper() OVERRIDE {
     return NULL;
   }
 
   virtual uint32 InsertSyncPoint() OVERRIDE {
     return 0;
   }
 
+  virtual void SetDeviceScaleFactor(float device_scale_factor) OVERRIDE {
+  }
+
   // We don't generate lost context events, so we don't need to keep track of
   // observers
   virtual void AddObserver(ImageTransportFactoryObserver* observer) OVERRIDE {
   }
 
   virtual void RemoveObserver(
       ImageTransportFactoryObserver* observer) OVERRIDE {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultTransportFactory);
 };
 
 class ImageTransportClientTexture : public ui::Texture {
  public:
   ImageTransportClientTexture(
       WebKit::WebGraphicsContext3D* host_context,
       const gfx::Size& size,
+      float device_scale_factor,
       uint64 surface_id)
-          : ui::Texture(true, size),
+          : ui::Texture(true, size, device_scale_factor),
             host_context_(host_context) {
     set_texture_id(surface_id);
   }
 
   virtual WebKit::WebGraphicsContext3D* HostContext3D() {
     return host_context_;
   }
 
  protected:
   virtual ~ImageTransportClientTexture() {}
 
  private:
   // A raw pointer. This |ImageTransportClientTexture| will be destroyed
   // before the |host_context_| via
   // |ImageTransportFactoryObserver::OnLostContext()| handlers.
   WebKit::WebGraphicsContext3D* host_context_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageTransportClientTexture);
 };
 
 class OwnedTexture : public ui::Texture, ImageTransportFactoryObserver {
  public:
   OwnedTexture(WebKit::WebGraphicsContext3D* host_context,
                const gfx::Size& size,
+               float device_scale_factor,
                unsigned int texture_id)
-      : ui::Texture(true, size),
+      : ui::Texture(true, size, device_scale_factor),
         host_context_(host_context) {
     ImageTransportFactory::GetInstance()->AddObserver(this);
     set_texture_id(texture_id);
   }
 
   // ui::Texture overrides:
   virtual WebKit::WebGraphicsContext3D* HostContext3D() OVERRIDE {
     return host_context_;
   }
 
@@ skipping 62 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(CompositorSwapClient);
 };
 
 class GpuProcessTransportFactory :
     public ui::ContextFactory,
     public ImageTransportFactory,
     public WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  public:
   GpuProcessTransportFactory()
-      : ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
+      : ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
+        device_scale_factor_(1.0f) {
   }
 
   virtual ~GpuProcessTransportFactory() {
     DCHECK(per_compositor_data_.empty());
   }
 
   virtual WebKit::WebGraphicsContext3D* CreateContext(
       ui::Compositor* compositor) OVERRIDE {
     PerCompositorData* data = per_compositor_data_[compositor];
     if (!data)
@@ skipping 58 matching lines @@
     shared_context_->flush();
   }
 
   virtual scoped_refptr<ui::Texture> CreateTransportClient(
       const gfx::Size& size,
       uint64 transport_handle) {
     if (!shared_context_.get())
         return NULL;
     scoped_refptr<ImageTransportClientTexture> image(
         new ImageTransportClientTexture(shared_context_.get(),
-                                        size, transport_handle));
+                                        size, device_scale_factor_,
+                                        transport_handle));
     return image;
   }
 
   virtual scoped_refptr<ui::Texture> CreateOwnedTexture(
       const gfx::Size& size,
       unsigned int texture_id) OVERRIDE {
     if (!shared_context_.get())
         return NULL;
     scoped_refptr<OwnedTexture> image(
-        new OwnedTexture(shared_context_.get(), size, texture_id));
+        new OwnedTexture(shared_context_.get(), size, device_scale_factor_,
+                         texture_id));
     return image;
   }
 
   virtual GLHelper* GetGLHelper() {
     if (!gl_helper_.get()) {
       CreateSharedContextLazy();
       WebKit::WebGraphicsContext3D* context_for_thread =
           CreateOffscreenContext();
       if (!context_for_thread)
         return NULL;
       gl_helper_.reset(new GLHelper(shared_context_.get(),
                                     context_for_thread));
     }
     return gl_helper_.get();
   }
 
   virtual uint32 InsertSyncPoint() OVERRIDE {
     if (!shared_context_.get())
       return 0;
     return shared_context_->insertSyncPoint();
   }
 
+  virtual void SetDeviceScaleFactor(float device_scale_factor) OVERRIDE {
+    device_scale_factor_ = device_scale_factor;
+  }
+
   virtual void AddObserver(ImageTransportFactoryObserver* observer) {
     observer_list_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(ImageTransportFactoryObserver* observer) {
     observer_list_.RemoveObserver(observer);
   }
 
   // WebGraphicsContextLostCallback implementation, called for the shared
   // context.
@@ skipping 105 matching lines @@
         observer_list_,
         OnLostResources());
   }
 
   typedef std::map<ui::Compositor*, PerCompositorData*> PerCompositorDataMap;
   PerCompositorDataMap per_compositor_data_;
   scoped_ptr<GLHelper> gl_helper_;
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> shared_context_;
   ObserverList<ImageTransportFactoryObserver> observer_list_;
   base::WeakPtrFactory<GpuProcessTransportFactory> callback_factory_;
+  float device_scale_factor_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuProcessTransportFactory);
 };
 
 void CompositorSwapClient::OnLostContext() {
   factory_->OnLostContext(compositor_);
   // Note: previous line destroyed this. Don't access members from now on.
 }
 
 WebKit::WebGraphicsContext3D* CreateTestContext() {
@@ skipping 25 matching lines @@
 void ImageTransportFactory::Terminate() {
   ui::ContextFactory::SetInstance(NULL);
   delete g_factory;
   g_factory = NULL;
 }
 
 // static
 ImageTransportFactory* ImageTransportFactory::GetInstance() {
   return g_factory;
 }