gpu: Record GL state to trace

gpu/command_buffer/service/gpu_state_tracer.cc

Index: gpu/command_buffer/service/gpu_state_tracer.cc
diff --git a/gpu/command_buffer/service/gpu_state_tracer.cc b/gpu/command_buffer/service/gpu_state_tracer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5b3988c09e8a87e848c1a4677fceb22217bfe60d
--- /dev/null
+++ b/gpu/command_buffer/service/gpu_state_tracer.cc
@@ -0,0 +1,133 @@
+// Copyright (c) 2013 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/gpu_state_tracer.h"
+
+#include <sstream>
+
+#include "base/base64.h"
+#include "base/debug/trace_event.h"
+#include "context_state.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gl/gl_bindings.h"
+
+namespace gpu {
+namespace gles2 {
+namespace {
+
+const int kBytesPerPixel = 4;
+
+class Snapshot : public base::debug::ConvertableToTraceFormat {
+ public:
+  static scoped_ptr<Snapshot> Create(const ContextState* state);
+
+  bool SaveScreenshot();
+
+  // base::debug::ConvertableToTraceFormat implementation.
+  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE;
+
+ private:
+  explicit Snapshot(const ContextState* state);
+
+  const ContextState* state_;
+
+  mutable std::vector<unsigned char> screenshot_pixels_;
+  gfx::Size screenshot_viewport_;
+
+  DISALLOW_COPY_AND_ASSIGN(Snapshot);
+};
+
+}  // namespace
+
+Snapshot::Snapshot(const ContextState* state) : state_(state) {}
+
+scoped_ptr<Snapshot> Snapshot::Create(const ContextState* state) {
+  return scoped_ptr<Snapshot>(new Snapshot(state));
+}
+
+bool Snapshot::SaveScreenshot() {
+  screenshot_viewport_ =
+      gfx::Size(state_->viewport_width, state_->viewport_height);

[piman, 2013/09/09 21:25:54]

You're dependent on the current GL state, which may not match at all the default
(or current) framebuffer size. Should we keep track of the default framebuffer
size (via HandleResizeCHROMIUM)?

+  screenshot_pixels_.resize(screenshot_viewport_.width() *
+                            screenshot_viewport_.height() * kBytesPerPixel);
+
+  glPixelStorei(GL_PACK_ALIGNMENT, kBytesPerPixel);
+  glReadPixels(state_->viewport_x,
+               state_->viewport_y,
+               screenshot_viewport_.width(),
+               screenshot_viewport_.height(),
+               GL_RGBA,
+               GL_UNSIGNED_BYTE,
+               &screenshot_pixels_[0]);
+  glPixelStorei(GL_PACK_ALIGNMENT, state_->pack_alignment);
+  return true;
+}
+
+void Snapshot::AppendAsTraceFormat(std::string* out) const {
+  *out += "{";
+  if (screenshot_pixels_.size()) {
+    // Flip the screenshot vertically.
+    int bytes_per_row = screenshot_viewport_.width() * kBytesPerPixel;
+    for (int y = 0; y < screenshot_viewport_.height() / 2; y++) {
+      for (int x = 0; x < bytes_per_row; x++) {
+        std::swap(
+            screenshot_pixels_[y * bytes_per_row + x],
+            screenshot_pixels_[
+                (screenshot_viewport_.height() - y - 1) * bytes_per_row + x]);

[piman, 2013/09/09 21:25:54]

Is this why you need screenshot_pixels_ to be mutable? Can't we do this in
SaveScreenshot instead?
Even though we probably don't do that, if we called AppendAsTraceFormat twice,
we'd get different results.

+      }
+    }
+
+    std::vector<unsigned char> png_data;
+    bool png_ok = gfx::PNGCodec::Encode(&screenshot_pixels_[0],
+                                        gfx::PNGCodec::FORMAT_RGBA,
+                                        screenshot_viewport_,
+                                        bytes_per_row,
+                                        false,
+                                        std::vector<gfx::PNGCodec::Comment>(),
+                                        &png_data);
+    DCHECK(png_ok);
+
+    base::StringPiece base64_input(reinterpret_cast<const char*>(&png_data[0]),
+                                   png_data.size());
+    std::string base64_output;
+    Base64Encode(base64_input, &base64_output);
+
+    *out += "\"screenshot\":\"" + base64_output + "\"";
+  }
+  *out += "}";
+}
+
+scoped_ptr<GPUStateTracer> GPUStateTracer::Create(const ContextState* state) {
+  return scoped_ptr<GPUStateTracer>(new GPUStateTracer(state));
+}
+
+GPUStateTracer::GPUStateTracer(const ContextState* state) : state_(state) {
+  TRACE_EVENT_OBJECT_CREATED_WITH_ID(
+      TRACE_DISABLED_BY_DEFAULT("gpu.debug"), "gpu::State", state_);
+}
+
+GPUStateTracer::~GPUStateTracer() {
+  TRACE_EVENT_OBJECT_DELETED_WITH_ID(
+      TRACE_DISABLED_BY_DEFAULT("gpu.debug"), "gpu::State", state_);
+}
+
+void GPUStateTracer::TakeSnapshot() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
+               "GPUStateTracer::TakeSnapshot");
+
+  scoped_ptr<Snapshot> snapshot(Snapshot::Create(state_));
+
+  // Only save a screenshot for now.
+  if (!snapshot->SaveScreenshot())
+    return;
+
+  TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
+      TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
+      "gpu::State",
+      state_,
+      snapshot.PassAs<base::debug::ConvertableToTraceFormat>());
+}
+
+}  // namespace gles2
+}  // namespace gpu