Restrict ETC1 power-of-two rounding to old IMG drivers.

content/browser/renderer_host/compositor_impl_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/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
@@ skipping 22 matching lines @@
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 namespace {
 
 const unsigned int kMaxSwapBuffers = 2U;
 
 // Used to override capabilities_.adjust_deadline_for_parent to false
 class OutputSurfaceWithoutParent : public cc::OutputSurface {
  public:
   OutputSurfaceWithoutParent(const scoped_refptr<
-      content::ContextProviderCommandBuffer>& context_provider)
+      content::ContextProviderCommandBuffer>& context_provider,
+      base::WeakPtr<content::CompositorImpl> compositor_impl)
       : cc::OutputSurface(context_provider) {
     capabilities_.adjust_deadline_for_parent = false;
+    compositor_impl_ = compositor_impl;
+    main_thread_ = base::MessageLoopProxy::current();
   }
 
   virtual void SwapBuffers(cc::CompositorFrame* frame) OVERRIDE {
     content::ContextProviderCommandBuffer* provider_command_buffer =
         static_cast<content::ContextProviderCommandBuffer*>(
             context_provider_.get());
     content::CommandBufferProxyImpl* command_buffer_proxy =
         provider_command_buffer->GetCommandBufferProxy();
     DCHECK(command_buffer_proxy);
     command_buffer_proxy->SetLatencyInfo(frame->metadata.latency_info);
 
     OutputSurface::SwapBuffers(frame);
   }
+
+  virtual bool BindToClient(cc::OutputSurfaceClient* client) OVERRIDE {
+    if (!OutputSurface::BindToClient(client))
+      return false;
+
+    main_thread_->PostTask(
+        FROM_HERE,
+        base::Bind(&content::CompositorImpl::PopulateGpuCapabilities,
+                   compositor_impl_,
+                   context_provider_->ContextCapabilities().gpu));
+
+    return true;
+  }
+
+  scoped_refptr<base::MessageLoopProxy> main_thread_;
+  base::WeakPtr<content::CompositorImpl> compositor_impl_;
 };
 
 class SurfaceTextureTrackerImpl : public gfx::SurfaceTextureTracker {
  public:
   SurfaceTextureTrackerImpl() : next_surface_texture_id_(1) {
     thread_checker_.DetachFromThread();
   }
 
   // Overridden from gfx::SurfaceTextureTracker:
   virtual scoped_refptr<gfx::SurfaceTexture> AcquireSurfaceTexture(
@@ skipping 460 matching lines @@
   if (gpu_channel_host && !gpu_channel_host->IsLost()) {
     context_provider = ContextProviderCommandBuffer::Create(
         CreateGpuProcessViewContext(gpu_channel_host, attrs, surface_id_),
         "BrowserCompositor");
   }
   if (!context_provider.get()) {
     LOG(ERROR) << "Failed to create 3D context for compositor.";
     return scoped_ptr<cc::OutputSurface>();
   }
 
-  return scoped_ptr<cc::OutputSurface>(
-      new OutputSurfaceWithoutParent(context_provider));
+  return scoped_ptr<cc::OutputSurface>(new OutputSurfaceWithoutParent(
+      context_provider, weak_factory_.GetWeakPtr()));
+}
+
+void CompositorImpl::PopulateGpuCapabilities(
+    gpu::Capabilities gpu_capabilities) {
+  ui_resource_provider_.SetSupportsETC1NonPowerOfTwo(
+      gpu_capabilities.texture_format_etc1_npot);
 }
 
 void CompositorImpl::OnLostResources() {
   client_->DidLoseResources();
   ui_resource_provider_.UIResourcesAreInvalid();
 }
 
 void CompositorImpl::ScheduleComposite() {
   DCHECK(!needs_composite_ || WillComposite());
   if (ignore_schedule_composite_)
@@ skipping 77 matching lines @@
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   if (!host_)
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content