Makes copying layers clone external textures.

content/common/gpu/client/gl_helper.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/common/gpu/client/gl_helper.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 241 matching lines @@
 
   void InitBuffer();
   void InitProgram();
 
   void CopyTextureTo(WebGLId src_texture,
                      const gfx::Size& src_size,
                      const gfx::Rect& src_subrect,
                      const gfx::Size& dst_size,
                      unsigned char* out,
                      const base::Callback<void(bool)>& callback);
+
+  WebKit::WebGLId CopyTexture(WebGLId src_texture, const gfx::Size& size);
+
  private:
   // A single request to CopyTextureTo.
   // Thread-safety notes: the main thread creates instances of this class. The
   // main thread can cancel the request, before it's handled by the helper
   // thread, by resetting the texture and pixels fields. Alternatively, the
   // thread marks that it handles the request by resetting the pixels field
   // (meaning it guarantees that the callback with be called).
   // In either case, the callback must be called exactly once, and the texture
   // must be deleted by the main thread context.
   struct Request : public base::RefCountedThreadSafe<Request> {
@@ skipping 232 matching lines @@
       new Request(this, texture, dst_size, out, callback);
   request_queue_.push(request);
 
   g_gl_helper_thread.Pointer()->message_loop_proxy()->PostTask(FROM_HERE,
       base::Bind(&ReadBackFramebuffer,
                  request,
                  context_for_thread_,
                  base::MessageLoopProxy::current()));
 }
 
+WebKit::WebGLId GLHelper::CopyTextureToImpl::CopyTexture(
+    WebGLId src_texture,
+    const gfx::Size& size) {
+  if (!context_for_thread_)
+    return 0;
+  return ScaleTexture(src_texture, size, gfx::Rect(size), size);
+}
+
 void GLHelper::CopyTextureToImpl::ReadBackFramebuffer(
     scoped_refptr<Request> request,
     WebGraphicsContext3D* context,
     scoped_refptr<base::TaskRunner> reply_loop) {
   DCHECK(context);
   if (!context->makeContextCurrent() || context->isContextLost()) {
     base::AutoLock auto_lock(request->lock);
     if (request->pixels) {
       // Only report failure if the request wasn't canceled (otherwise the
       // failure has already been reported).
@@ skipping 119 matching lines @@
 WebGraphicsContext3D* GLHelper::context() const {
   return context_;
 }
 
 void GLHelper::CopyTextureTo(WebGLId src_texture,
                              const gfx::Size& src_size,
                              const gfx::Rect& src_subrect,
                              const gfx::Size& dst_size,
                              unsigned char* out,
                              const base::Callback<void(bool)>& callback) {
-  // Lazily initialize |copy_texture_to_impl_|
-  if (!copy_texture_to_impl_.get())
-    copy_texture_to_impl_.reset(new CopyTextureToImpl(context_,
-                                                      context_for_thread_,
-                                                      this));
-
+  InitCopyTextToImpl();
   copy_texture_to_impl_->CopyTextureTo(src_texture,
                                        src_size,
                                        src_subrect,
                                        dst_size,
                                        out,
                                        callback);
 }
 
+WebKit::WebGLId GLHelper::CopyTexture(WebKit::WebGLId texture,
+                                      const gfx::Size& size) {
+  InitCopyTextToImpl();
+  return copy_texture_to_impl_->CopyTexture(texture, size);
+}
+
 WebGLId GLHelper::CompileShaderFromSource(
     const WebKit::WGC3Dchar* source,
     WebKit::WGC3Denum type) {
   ScopedShader shader(context_, context_->createShader(type));
   context_->shaderSource(shader, source);
   context_->compileShader(shader);
   WebKit::WGC3Dint compile_status = 0;
   context_->getShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
   if (!compile_status) {
     LOG(ERROR) << std::string(context_->getShaderInfoLog(shader).utf8());
     return 0;
   }
   return shader.Detach();
 }
 
+void GLHelper::InitCopyTextToImpl() {
+  // Lazily initialize |copy_texture_to_impl_|
+  if (!copy_texture_to_impl_.get())
+    copy_texture_to_impl_.reset(new CopyTextureToImpl(context_,
+                                                      context_for_thread_,
+                                                      this));
+
+}
+
 }  // namespace content