Added a unique command buffer ID for command buffers.

gpu/command_buffer/common/command_buffer.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_COMMON_COMMAND_BUFFER_H_
 #define GPU_COMMAND_BUFFER_COMMON_COMMAND_BUFFER_H_
 
+#include "base/logging.h"
 #include "gpu/command_buffer/common/buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/gpu_export.h"
 
 namespace base {
 class SharedMemory;
 }
 
 namespace gpu {
 
+enum CommandBufferNamespace {
+  kCommandBufferNamespace_Invalid = -1,
+
+  kCommandBufferNamespace_GpuIO,
+  kCommandBufferNamespace_InProcess,
+
+  NUM_COMMAND_BUFFER_NAMESPACES
+};
+
 // Common interface for CommandBuffer implementations.
 class GPU_EXPORT CommandBuffer {

[piman, 2015/09/15 22:51:05]

This is a virtual interface, it should not have members so that it can be used
for multiple interface inheritance.
We could add a (pure virtual) GetNamespaceId/GetCommandBufferId, but they need
to be implemented by concrete classes.
But I'm not really sure this belongs in this interface. On the client side, this
can go onto GpuControl. On the service side, AIUI only GLES2Decoder/ContextGroup
needs it, and can be given explicitly by its owner
(GpuCommandBufferStub/InProcessCommandBuffer).

[David Yen, 2015/09/15 23:09:03]

Doesn't it makes sense to put it as part of the command buffer class if this is
a way to uniquely identify command buffers? It is also convenient that the enum
is also declared here (which we wouldn't be able to do since GpuControl is only
client code).

[piman, 2015/09/15 23:17:17]

I'd strongly prefer CommandBuffer to only worry about executing commands, and
not have higher level features (channels, synchronization between them, threads
etc.) leak into it.
CommandBuffer doesn't know anything about the commands themselves, or GL or
higher-level semantics.

[David Yen, 2015/09/16 00:02:50]

Ok, I've moved it to GpuControl as you suggested.

  public:
   struct State {
     State()
         : get_offset(0),
           token(-1),
           error(error::kNoError),
           context_lost_reason(error::kUnknown),
           generation(0) {
     }
 
@@ skipping 19 matching lines @@
     uint32 generation;
   };
 
   struct ConsoleMessage {
     // An user supplied id.
     int32 id;
     // The message.
     std::string message;
   };
 
-  CommandBuffer() {
+  explicit CommandBuffer(CommandBufferNamespace namespace_id,
+                uint64_t command_buffer_id)
+    : namespace_id_(namespace_id),
+      command_buffer_id_(command_buffer_id) {
   }
 
   virtual ~CommandBuffer() {
   }
 
   // Check if a value is between a start and end value, inclusive, allowing
   // for wrapping if start > end.
   static bool InRange(int32 start, int32 end, int32 value) {
     if (start <= end)
       return start <= value && value <= end;
@@ skipping 49 matching lines @@
 // GetLastError declared would mean we'd have to also define it, and pull more
 // of gpu in to the NaCl Win64 build.
 #if !defined(NACL_WIN64)
   // TODO(apatrick): this is a temporary optimization while skia is calling
   // RendererGLContext::MakeCurrent prior to every GL call. It saves returning 6
   // ints redundantly when only the error is needed for the CommandBufferProxy
   // implementation.
   virtual error::Error GetLastError();
 #endif
 
+  // The namespace and command buffer ID forms a unique pair for all existing
+  // command buffers in a single process. Intermediate command buffers
+  // (such as CommandBufferService) should assign have an invalid namespace
+  // to signify that they should not be queried. Command Buffers that forward
+  // messages to other command buffers should identify as the command buffer
+  // which actually does the executions.
+  CommandBufferNamespace namespace_id() const {
+    DCHECK_NE(namespace_id_, kCommandBufferNamespace_Invalid);
+    return namespace_id_;
+  }
+
+  uint64_t command_buffer_id() const {
+    DCHECK_NE(namespace_id_, kCommandBufferNamespace_Invalid);
+    return command_buffer_id_;
+  }
+
  private:
+  const CommandBufferNamespace namespace_id_;
+  const uint64_t command_buffer_id_;
+
   DISALLOW_COPY_AND_ASSIGN(CommandBuffer);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_COMMAND_BUFFER_H_