Modified GPU command signature hash to use a binary representation.

gpu/command_buffer/service/renderbuffer_manager.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/service/renderbuffer_manager.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "ui/gl/gl_implementation.h"
 
 namespace gpu {
 namespace gles2 {
 
+// The should contain everything to uniquely identify a Renderbuffer.

[vmiura, 2014/09/26 23:36:36]

nit: This

[David Yen, 2014/09/29 16:42:58]

Done.

+static const char RenderbufferTag[] = "|Renderbuffer|";
+struct RenderbufferSignature {
+  GLenum internal_format_;
+  GLsizei samples_;
+  GLsizei width_;
+  GLsizei height_;
+
+  // Since we will be hashing this signature structure, the padding must be
+  // zero initialized. Although the C++11 specifications specify that this is
+  // true, we will use a constructor with a memset to further enforce it instead
+  // of relying on compilers adhering to this deep dark corner specification.
+  RenderbufferSignature(GLenum internal_format,
+                        GLsizei samples,
+                        GLsizei width,
+                        GLsizei height) {
+    memset(this, 0, sizeof(RenderbufferSignature));
+    internal_format_ = internal_format;
+    samples_ = samples;
+    width_ = width;
+    height_ = height;
+  }
+};
+
 RenderbufferManager::RenderbufferManager(
     MemoryTracker* memory_tracker,
     GLint max_renderbuffer_size,
     GLint max_samples,
     bool depth24_supported)
     : memory_tracker_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
       max_renderbuffer_size_(max_renderbuffer_size),
       max_samples_(max_samples),
       depth24_supported_(depth24_supported),
@@ skipping 11 matching lines @@
   DCHECK_EQ(0, num_uncleared_renderbuffers_);
 }
 
 size_t Renderbuffer::EstimatedSize() {
   uint32 size = 0;
   manager_->ComputeEstimatedRenderbufferSize(
       width_, height_, samples_, internal_format_, &size);
   return size;
 }
 
-void Renderbuffer::AddToSignature(
-    std::string* signature) const {
+
+size_t Renderbuffer::GetSignatureSize() const {
+  return sizeof(RenderbufferTag) + sizeof(RenderbufferSignature);
+}
+
+void Renderbuffer::AddToSignature(std::string* signature) const {
   DCHECK(signature);
-  *signature += base::StringPrintf(
-      "|Renderbuffer|internal_format=%04x|samples=%d|width=%d|height=%d",
-      internal_format_, samples_, width_, height_);
+  RenderbufferSignature signature_data(internal_format_,
+                                       samples_,
+                                       width_,
+                                       height_);
+
+  signature->append(RenderbufferTag, sizeof(RenderbufferTag));
+  signature->append(reinterpret_cast<const char*>(&signature_data),
+                    sizeof(signature_data));
 }
 
 Renderbuffer::Renderbuffer(RenderbufferManager* manager,
                            GLuint client_id,
                            GLuint service_id)
     : manager_(manager),
       client_id_(client_id),
       service_id_(service_id),
       cleared_(true),
       has_been_bound_(false),
@@ skipping 127 matching lines @@
     if (impl_format == GL_DEPTH_COMPONENT16 && depth24_supported_)
       return GL_DEPTH_COMPONENT24;
   }
   return impl_format;
 }
 
 }  // namespace gles2
 }  // namespace gpu