Perform glReadPixels with PBOs in the gpu, if PBOs are available.

gpu/command_buffer/client/gl_in_process_context.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 "gpu/command_buffer/client/gl_in_process_context.h"
 
+#include <deque>
 #include <utility>
 #include <vector>
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
@@ skipping 99 matching lines @@
   gles2::GLES2Decoder* GetDecoder();
   bool GetBufferChanged(int32 transfer_buffer_id);
   void PumpCommands();
   void OnResizeView(gfx::Size size, float scale_factor);
   void OnContextLost();
 
  private:
   void Destroy();
   bool IsCommandBufferContextLost();
   void PollQueryCallbacks();
-  void CallQueryCallback(size_t index);
 
   gles2::ImageManager* GetImageManager();
 
   base::Closure context_lost_callback_;
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<CommandBuffer> command_buffer_;
   scoped_ptr<GpuScheduler> gpu_scheduler_;
   scoped_ptr<gles2::GLES2Decoder> decoder_;
   scoped_refptr<gfx::GLContext> context_;
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_ptr<gles2::GLES2CmdHelper> gles2_helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
   scoped_ptr<gles2::GLES2Implementation> gles2_implementation_;
   scoped_refptr<ImageFactoryInProcess> image_factory_;
   base::Closure signal_sync_point_callback_;
   bool share_resources_;
   bool context_lost_;
 
   typedef std::pair<unsigned, base::Closure> QueryCallback;
-  std::vector<QueryCallback> query_callbacks_;
+  std::deque<QueryCallback> query_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(GLInProcessContextImpl);
 };
 
 AutoLockAndDecoderDetachThread::AutoLockAndDecoderDetachThread(
     base::Lock& lock,
     const std::set<GLInProcessContextImpl*>& contexts)
     : auto_lock_(lock),
       contexts_(contexts) {
 }
@@ skipping 340 matching lines @@
                                         g_all_shared_contexts.Get());
     g_all_shared_contexts.Pointer()->insert(this);
   }
 
   context_lost_callback_ = context_lost_callback;
   return true;
 }
 
 void GLInProcessContextImpl::Destroy() {
   while (!query_callbacks_.empty()) {
-    CallQueryCallback(0);
+    base::Closure query_callback = query_callbacks_.back().second;
+    query_callbacks_.pop_back();
+    query_callback.Run();
   }
 
+
   bool context_lost = IsCommandBufferContextLost();
 
   if (gles2_implementation_) {
     // First flush the context to ensure that any pending frees of resources
     // are completed. Otherwise, if this context is part of a share group,
     // those resources might leak. Also, any remaining side effects of commands
     // issued on this context might not be visible to other contexts in the
     // share group.
     gles2_implementation_->Flush();
 
@@ skipping 20 matching lines @@
   context_lost_ = true;
   if (share_resources_) {
       for (std::set<GLInProcessContextImpl*>::iterator it =
                g_all_shared_contexts.Get().begin();
            it != g_all_shared_contexts.Get().end();
            ++it)
         (*it)->context_lost_ = true;
   }
 }
 
-void GLInProcessContextImpl::CallQueryCallback(size_t index) {
-  DCHECK_LT(index, query_callbacks_.size());
-  QueryCallback query_callback = query_callbacks_[index];
-  query_callbacks_[index] = query_callbacks_.back();
-  query_callbacks_.pop_back();
-  query_callback.second.Run();
-}
-
 void GLInProcessContextImpl::PollQueryCallbacks() {
-  for (size_t i = 0; i < query_callbacks_.size();) {
+  // Queries are put on to to the query_callback_ deque from the FRONT.
+  // This means that if there are several queries of the same type in
+  // the queue, and we find that one of them has finished, the rest
+  // of them should be finished too. We want to make sure that

[piman, 2013/06/28 23:35:46]

That's not true though.
An async texture upload doesn't complete in order wrt other GL commands (or each
other for that matter).
Besides, the dequeue is filled in order of SignalQuery, not EngQuery, and so
even if the queries did complete in order (of EndQuery!), you couldn't have this
guarantee.

[hubbe, 2013/06/29 00:13:56]

Async readpixels (and maybe other queries) *do* finish in the order they were
scheduled, and it's not unreasonable to assume that if you call signalQuery
right after endQuery, the callbacks will come back in a reasonable order.
(gl_helper.cc makes this assumption right now, so it's either change this code,
gl_helper.cc or both...)

Also, on a grander scale, the tab capture code prefers to have the frames
returned in order, which becomes much easier if you can rely on the callbacks to
maintain their order.

I added a comment clarifying that this doesn't apply to all query types though.

+  //  a) Query callbacks are called in the right order
+  //  b) query_callbacks_ is in a good state when we call the callbacks
+  // To do that we pul out the queries that have completed and put them
+  // in a separate container in reversed order, then we compress
+  // query_callbacks_ and before invoking the callbacks.
+  std::deque<QueryCallback> to_call;
+  size_t queries_left = 0;
+  for (size_t i = 0; i < query_callbacks_.size(); i++) {
     unsigned query = query_callbacks_[i].first;
     GLuint param = 0;
     gles2::GLES2Implementation* gl = GetImplementation();
     if (gl->IsQueryEXT(query)) {
       gl->GetQueryObjectuivEXT(query, GL_QUERY_RESULT_AVAILABLE_EXT, &param);
     } else {
       param = 1;
     }
     if (param) {
-      CallQueryCallback(i);
+      to_call.push_front(query_callbacks_[i]);
     } else {
-      i++;
+      query_callbacks_[queries_left++] = query_callbacks_[i];
     }
   }
+  query_callbacks_.resize(queries_left);
+  for (size_t i = 0; i < to_call.size(); i++) {
+    to_call[i].second.Run();
+  }
+
   if (!query_callbacks_.empty()) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&GLInProcessContextImpl::PollQueryCallbacks,
                    this->AsWeakPtr()),
         base::TimeDelta::FromMilliseconds(5));
   }
 }
 
 void GLInProcessContextImpl::SignalQuery(
     unsigned query,
     const base::Closure& callback) {
-  query_callbacks_.push_back(std::make_pair(query, callback));
+  query_callbacks_.push_front(std::make_pair(query, callback));
   // If size > 1, there is already a poll callback pending.
   if (query_callbacks_.size() == 1) {
     PollQueryCallbacks();
   }
 }
 
 }  // anonymous namespace
 
 // static
 GLInProcessContext* GLInProcessContext::CreateContext(
@@ skipping 32 matching lines @@
   {
     AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
                                         g_all_shared_contexts.Get());
     DCHECK(g_all_shared_contexts.Get().empty());
   }
 #endif  // !defined(NDEBUG)
   g_use_virtualized_gl_context = true;
 }
 
 }  // namespace gpu