mustash: gpu: implement SignalQuery in CommandBufferLocal

components/mus/gles2/command_buffer_local.cc

 // Copyright 2015 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 "components/mus/gles2/command_buffer_local.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/memory/shared_memory.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/mus/gles2/command_buffer_driver.h"
 #include "components/mus/gles2/command_buffer_local_client.h"
 #include "components/mus/gles2/command_buffer_type_conversions.h"
 #include "components/mus/gles2/gpu_memory_tracker.h"
 #include "components/mus/gles2/gpu_state.h"
 #include "components/mus/gles2/mojo_buffer_backing.h"
 #include "components/mus/gles2/mojo_gpu_memory_buffer.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
+#include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "mojo/platform_handle/platform_handle_functions.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
 
@@ skipping 283 matching lines @@
                                 base::Unretained(this), sync_point));
 }
 
 void CommandBufferLocal::SignalSyncPoint(uint32_t sync_point,
                                          const base::Closure& callback) {
   DCHECK(CalledOnValidThread());
   gpu_state_->sync_point_manager()->AddSyncPointCallback(sync_point,
       base::Bind(&PostTask, client_thread_task_runner_, callback));
 }
 
-void CommandBufferLocal::SignalQuery(uint32_t query,
+void CommandBufferLocal::SignalQuery(uint32_t query_id,
                                      const base::Closure& callback) {
   DCHECK(CalledOnValidThread());
-  // TODO(piman)
-  NOTIMPLEMENTED();
+
+  gpu::gles2::QueryManager* query_manager =
+      driver_->GetDecoder()->GetQueryManager();
+  DCHECK(query_manager);
+
+  gpu::gles2::QueryManager::Query* query = query_manager->GetQuery(query_id);

[Peng, 2016/01/20 19:57:13]

CommandBufferLocal::SignalQuery() is called on the client thread (the mus main
thread), the QueryManager is used on the GPU thread. Seems GetQuery() &
AddCallback() are not thread safe (see [1]). So I think you have to post a task
to client GPU thread, and then execute those code. And I believe the callback
passed to query->AddCallback() will be invoked on the GPU thread, but the
callback of SignalQuery() should be called on the client thread, so you have to
some extra work for it (Like the code at line 327).


BTW, you may consider adding a SignalQuery() in CommandBufferDriver instead of
exposing decoder to CommandBufferLocal. And call it from
CommandBufferLocal::SignalQueryOnGpuThread()



[1]
https://code.google.com/p/chromium/codesearch#chromium/src/gpu/command_buffer...

[Hadi, 2016/01/20 21:33:29]

Done. Used gpu_state_->command_buffer_task_runner()->PostTask() to send tasks to
GPU thread.

+  if (query)
+    query->AddCallback(callback);
+  else
+    callback.Run();
 }
 
 void CommandBufferLocal::SetLock(base::Lock* lock) {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
 bool CommandBufferLocal::IsGpuChannelLost() {
   DCHECK(CalledOnValidThread());
   // This is only possible for out-of-process command buffers.
@@ skipping 212 matching lines @@
     client_->DidLoseContext();
 }
 
 void CommandBufferLocal::UpdateVSyncParametersOnClientThread(int64_t timebase,
                                                              int64_t interval) {
   if (client_)
     client_->UpdateVSyncParameters(timebase, interval);
 }
 
 }  // namespace mus