Move GPU messages to content. I've also switched the IPC structs to use the new IPC macros that generate serialization code.

Review URL: http://codereview.chromium.org/6673003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@77721 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 802 insertions, 9 deletions

diff --git a/content/DEPS b/content/DEPS
index b5cb1c7..a5184fb 100644
--- a/content/DEPS
+++ b/content/DEPS
@@ -9,6 +9,7 @@ include_rules = [
   "+chrome",
 
   "+grit",
+  "+gpu",
   "+media",
   "+net",
   "+ppapi",
diff --git a/content/browser/gpu_blacklist.cc b/content/browser/gpu_blacklist.cc
index ce54c28..9130149 100644
--- a/content/browser/gpu_blacklist.cc
+++ b/content/browser/gpu_blacklist.cc
@@ -14,7 +14,7 @@
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "base/version.h"
-#include "chrome/common/gpu_info.h"
+#include "content/common/gpu_info.h"
 
 namespace {
 
diff --git a/content/browser/gpu_blacklist_unittest.cc b/content/browser/gpu_blacklist_unittest.cc
index 6008b62..0394a06 100644
--- a/content/browser/gpu_blacklist_unittest.cc
+++ b/content/browser/gpu_blacklist_unittest.cc
@@ -10,8 +10,8 @@
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/version.h"
-#include "chrome/common/gpu_info.h"
 #include "content/browser/gpu_blacklist.h"
+#include "content/common/gpu_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class GpuBlacklistTest : public testing::Test {
diff --git a/content/browser/gpu_process_host.cc b/content/browser/gpu_process_host.cc
index e89a46e..900abff 100644
--- a/content/browser/gpu_process_host.cc
+++ b/content/browser/gpu_process_host.cc
@@ -17,12 +17,12 @@
 #include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_feature_flags.h"
-#include "chrome/common/gpu_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/gpu/gpu_thread.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
+#include "content/common/gpu_messages.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
diff --git a/content/browser/renderer_host/gpu_message_filter.cc b/content/browser/renderer_host/gpu_message_filter.cc
index 9222e10..87d2362 100644
--- a/content/browser/renderer_host/gpu_message_filter.cc
+++ b/content/browser/renderer_host/gpu_message_filter.cc
@@ -10,10 +10,9 @@
 
 #include "base/callback.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
-#include "chrome/common/gpu_create_command_buffer_config.h"
-#include "chrome/common/gpu_messages.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/gpu_process_host.h"
+#include "content/common/gpu_messages.h"
 
 GpuMessageFilter::GpuMessageFilter(int render_process_id)
     : gpu_host_id_(0),
@@ -92,10 +91,8 @@ class EstablishChannelCallback
 #endif
 
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    ViewMsg_GpuChannelEstablished* reply =
-        new ViewMsg_GpuChannelEstablished(channel,
-                                          renderer_process_for_gpu,
-                                          gpu_info);
+    IPC::Message* reply = new GpuMsg_GpuChannelEstablished(
+        channel, renderer_process_for_gpu, gpu_info);
 
     // If the renderer process is performing synchronous initialization,
     // it needs to handle this message before receiving the reply for
diff --git a/content/common/common_param_traits.cc b/content/common/common_param_traits.cc
index b5ba062..948576b 100644
--- a/content/common/common_param_traits.cc
+++ b/content/common/common_param_traits.cc
@@ -8,6 +8,7 @@
 #include "net/base/host_port_pair.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
+#include "ui/gfx/rect.h"
 #include "webkit/glue/resource_loader_bridge.h"
 
 namespace IPC {
@@ -470,4 +471,69 @@ void ParamTraits<base::PlatformFileInfo>::Log(
   l->append(")");
 }
 
+void ParamTraits<gfx::Point>::Write(Message* m, const gfx::Point& p) {
+  m->WriteInt(p.x());
+  m->WriteInt(p.y());
+}
+
+bool ParamTraits<gfx::Point>::Read(const Message* m, void** iter,
+                                   gfx::Point* r) {
+  int x, y;
+  if (!m->ReadInt(iter, &x) ||
+      !m->ReadInt(iter, &y))
+    return false;
+  r->set_x(x);
+  r->set_y(y);
+  return true;
+}
+
+void ParamTraits<gfx::Point>::Log(const gfx::Point& p, std::string* l) {
+  l->append(base::StringPrintf("(%d, %d)", p.x(), p.y()));
+}
+
+void ParamTraits<gfx::Size>::Write(Message* m, const gfx::Size& p) {
+  m->WriteInt(p.width());
+  m->WriteInt(p.height());
+}
+
+bool ParamTraits<gfx::Size>::Read(const Message* m, void** iter, gfx::Size* r) {
+  int w, h;
+  if (!m->ReadInt(iter, &w) ||
+      !m->ReadInt(iter, &h))
+    return false;
+  r->set_width(w);
+  r->set_height(h);
+  return true;
+}
+
+void ParamTraits<gfx::Size>::Log(const gfx::Size& p, std::string* l) {
+  l->append(base::StringPrintf("(%d, %d)", p.width(), p.height()));
+}
+
+void ParamTraits<gfx::Rect>::Write(Message* m, const gfx::Rect& p) {
+  m->WriteInt(p.x());
+  m->WriteInt(p.y());
+  m->WriteInt(p.width());
+  m->WriteInt(p.height());
+}
+
+bool ParamTraits<gfx::Rect>::Read(const Message* m, void** iter, gfx::Rect* r) {
+  int x, y, w, h;
+  if (!m->ReadInt(iter, &x) ||
+      !m->ReadInt(iter, &y) ||
+      !m->ReadInt(iter, &w) ||
+      !m->ReadInt(iter, &h))
+    return false;
+  r->set_x(x);
+  r->set_y(y);
+  r->set_width(w);
+  r->set_height(h);
+  return true;
+}
+
+void ParamTraits<gfx::Rect>::Log(const gfx::Rect& p, std::string* l) {
+  l->append(base::StringPrintf("(%d, %d, %d, %d)", p.x(), p.y(),
+                               p.width(), p.height()));
+}
+
 }  // namespace IPC
diff --git a/content/common/common_param_traits.h b/content/common/common_param_traits.h
index f6f79b6..20c5be3 100644
--- a/content/common/common_param_traits.h
+++ b/content/common/common_param_traits.h
@@ -27,11 +27,18 @@
 
 // TODO(erg): The following headers are historical and only work because
 // their definitions are inlined, which also needs to be fixed.
+#include "ui/gfx/native_widget_types.h"
 #include "webkit/glue/resource_type.h"
 
 // Forward declarations.
 class GURL;
 
+namespace gfx {
+class Point;
+class Rect;
+class Size;
+}  // namespace gfx
+
 namespace net {
 class HttpResponseHeaders;
 class HostPortPair;
@@ -122,6 +129,62 @@ struct SimilarTypeTraits<base::PlatformFileError> {
   typedef int Type;
 };
 
+template <>
+struct ParamTraits<gfx::Point> {
+  typedef gfx::Point param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct ParamTraits<gfx::Size> {
+  typedef gfx::Size param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct ParamTraits<gfx::Rect> {
+  typedef gfx::Rect param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
+struct ParamTraits<gfx::NativeWindow> {
+  typedef gfx::NativeWindow param_type;
+  static void Write(Message* m, const param_type& p) {
+#if defined(OS_WIN)
+    // HWNDs are always 32 bits on Windows, even on 64 bit systems.
+    m->WriteUInt32(reinterpret_cast<uint32>(p));
+#else
+    m->WriteData(reinterpret_cast<const char*>(&p), sizeof(p));
+#endif
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+#if defined(OS_WIN)
+    return m->ReadUInt32(iter, reinterpret_cast<uint32*>(r));
+#else
+    const char *data;
+    int data_size = 0;
+    bool result = m->ReadData(iter, &data, &data_size);
+    if (result && data_size == sizeof(gfx::NativeWindow)) {
+      memcpy(r, data, sizeof(gfx::NativeWindow));
+    } else {
+      result = false;
+      NOTREACHED();
+    }
+    return result;
+#endif
+  }
+  static void Log(const param_type& p, std::string* l) {
+    l->append("<gfx::NativeWindow>");
+  }
+};
+
 }  // namespace IPC
 
 #endif  // CONTENT_COMMON_COMMON_PARAM_TRAITS_H_
diff --git a/content/common/content_message_generator.h b/content/common/content_message_generator.h
index 619e26c..69d16bc8 100644
--- a/content/common/content_message_generator.h
+++ b/content/common/content_message_generator.h
@@ -7,5 +7,6 @@
 #include "content/common/child_process_messages.h"
 #include "content/common/file_system_messages.h"
 #include "content/common/p2p_messages.h"
+#include "content/common/gpu_messages.h"
 #include "content/common/resource_messages.h"
 #include "content/common/socket_stream_messages.h"
diff --git a/content/common/dx_diag_node.cc b/content/common/dx_diag_node.cc
new file mode 100644
index 0000000..566cd4a
--- /dev/null
+++ b/content/common/dx_diag_node.cc
@@ -0,0 +1,9 @@
+// Copyright (c) 2010 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 "content/common/dx_diag_node.h"
+
+DxDiagNode::DxDiagNode() {}
+
+DxDiagNode::~DxDiagNode() {}
diff --git a/content/common/dx_diag_node.h b/content/common/dx_diag_node.h
new file mode 100644
index 0000000..8e3f2e3
--- /dev/null
+++ b/content/common/dx_diag_node.h
@@ -0,0 +1,22 @@
+// Copyright (c) 2010 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.
+//
+// A tree of name value pairs that report contain DirectX diagnostic
+// information.
+
+#ifndef CONTENT_COMMON_DX_DIAG_NODE_H_
+#define CONTENT_COMMON_DX_DIAG_NODE_H_
+
+#include <map>
+#include <string>
+
+struct DxDiagNode {
+  DxDiagNode();
+  ~DxDiagNode();
+
+  std::map<std::string, std::string> values;
+  std::map<std::string, DxDiagNode> children;
+};
+
+#endif  // CONTENT_COMMON_DX_DIAG_NODE_H_
diff --git a/content/common/gpu_info.cc b/content/common/gpu_info.cc
new file mode 100644
index 0000000..55ecdbc
--- /dev/null
+++ b/content/common/gpu_info.cc
@@ -0,0 +1,26 @@
+// Copyright (c) 2011 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 "content/common/gpu_info.h"
+
+GPUInfo::GPUInfo()
+    : level(kUninitialized),
+      vendor_id(0),
+      device_id(0),
+      driver_vendor(""),
+      driver_version(""),
+      driver_date(""),
+      pixel_shader_version(0),
+      vertex_shader_version(0),
+      gl_version(0),
+      gl_version_string(""),
+      gl_vendor(""),
+      gl_renderer(""),
+      gl_extensions(""),
+      can_lose_context(false),
+      collection_error(false) {
+}
+
+GPUInfo::~GPUInfo() {
+}
diff --git a/content/common/gpu_info.h b/content/common/gpu_info.h
new file mode 100644
index 0000000..b571682
--- /dev/null
+++ b/content/common/gpu_info.h
@@ -0,0 +1,100 @@
+// Copyright (c) 2011 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 CONTENT_COMMON_GPU_INFO_H_
+#define CONTENT_COMMON_GPU_INFO_H_
+#pragma once
+
+// Provides access to the GPU information for the system
+// on which chrome is currently running.
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/time.h"
+#include "build/build_config.h"
+#include "content/common/dx_diag_node.h"
+
+struct GPUInfo {
+  GPUInfo();
+  ~GPUInfo();
+
+  enum Level {
+    kUninitialized,
+    kPreliminary,
+    kPartial,
+    kCompleting,
+    kComplete,
+  };
+
+  // Whether this GPUInfo has been partially or fully initialized with
+  // information.
+  Level level;
+
+  // The amount of time taken to get from the process starting to the message
+  // loop being pumped.
+  base::TimeDelta initialization_time;
+
+  // The DWORD (uint32) representing the graphics card vendor id.
+  uint32 vendor_id;
+
+  // The DWORD (uint32) representing the graphics card device id.  Device ids
+  // are unique to vendor, not to one another.
+  uint32 device_id;
+
+  // The vendor of the graphics driver currently installed.
+  std::string driver_vendor;
+
+  // The version of the graphics driver currently installed.
+  std::string driver_version;
+
+  // The date of the graphics driver currently installed.
+  std::string driver_date;
+
+  // The version of the pixel/fragment shader used by the gpu.  Major version in
+  // the second lowest 8 bits, minor in the lowest 8 bits, eg version 2.5 would
+  // be 0x00000205.
+  uint32 pixel_shader_version;
+
+  // The version of the vertex shader used by the gpu.  Major version in the
+  // second lowest 8 bits, minor in the lowest 8 bits, eg version 2.5 would be
+  // 0x00000205.
+  uint32 vertex_shader_version;
+
+  // The version of OpenGL we are using.
+  // Major version in the second lowest 8 bits, minor in the lowest 8 bits,
+  // eg version 2.5 would be 0x00000205.
+  // Returns 0 if we're not using OpenGL, say because we're going through
+  // D3D instead.
+  // TODO(zmo): should be able to tell if it's GL or GLES.
+  uint32 gl_version;
+
+  // The GL_VERSION string.  "" if we are not using OpenGL.
+  std::string gl_version_string;
+
+  // The GL_VENDOR string.  "" if we are not using OpenGL.
+  std::string gl_vendor;
+
+  // The GL_RENDERER string.  "" if we are not using OpenGL.
+  std::string gl_renderer;
+
+  // The GL_EXTENSIONS string.  "" if we are not using OpenGL.
+  std::string gl_extensions;
+
+  // The device semantics, i.e. whether the Vista and Windows 7 specific
+  // semantics are available.
+  bool can_lose_context;
+
+  // True if there was an error at any stage of collecting GPUInfo data.
+  // If there was an error, then the GPUInfo fields may be incomplete or set
+  // to default values such as 0 or empty string.
+  bool collection_error;
+
+#if defined(OS_WIN)
+  // The information returned by the DirectX Diagnostics Tool.
+  DxDiagNode dx_diagnostics;
+#endif
+};
+
+#endif  // CONTENT_COMMON_GPU_INFO_H_
diff --git a/content/common/gpu_info_unittest.cc b/content/common/gpu_info_unittest.cc
new file mode 100644
index 0000000..8e99e37
--- /dev/null
+++ b/content/common/gpu_info_unittest.cc
@@ -0,0 +1,26 @@
+// Copyright (c) 2010 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 "content/common/gpu_info.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// Test that an empty GPUInfo has valid members
+TEST(GPUInfoBasicTest, EmptyGPUInfo) {
+  GPUInfo gpu_info;
+  EXPECT_EQ(gpu_info.level, GPUInfo::kUninitialized);
+  EXPECT_EQ(gpu_info.initialization_time.ToInternalValue(), 0);
+  EXPECT_EQ(gpu_info.vendor_id, 0u);
+  EXPECT_EQ(gpu_info.device_id, 0u);
+  EXPECT_EQ(gpu_info.driver_vendor, "");
+  EXPECT_EQ(gpu_info.driver_version, "");
+  EXPECT_EQ(gpu_info.driver_date, "");
+  EXPECT_EQ(gpu_info.pixel_shader_version, 0u);
+  EXPECT_EQ(gpu_info.vertex_shader_version, 0u);
+  EXPECT_EQ(gpu_info.gl_version, 0u);
+  EXPECT_EQ(gpu_info.gl_version_string, "");
+  EXPECT_EQ(gpu_info.gl_vendor, "");
+  EXPECT_EQ(gpu_info.gl_renderer, "");
+  EXPECT_EQ(gpu_info.gl_extensions, "");
+  EXPECT_EQ(gpu_info.can_lose_context, false);
+}
diff --git a/content/common/gpu_messages.h b/content/common/gpu_messages.h
new file mode 100644
index 0000000..558f6b3
--- /dev/null
+++ b/content/common/gpu_messages.h
@@ -0,0 +1,477 @@
+// Copyright (c) 2011 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 <vector>
+#include <string>
+
+#include "base/shared_memory.h"
+#include "content/common/common_param_traits.h"
+#include "content/common/gpu_info.h"
+#include "gpu/ipc/gpu_command_buffer_traits.h"
+#include "gpu/command_buffer/common/command_buffer.h"
+#include "ipc/ipc_channel_handle.h"
+#include "ipc/ipc_message_macros.h"
+#include "ui/gfx/native_widget_types.h"
+#include "ui/gfx/size.h"
+
+// Multiply-included message file, hence no include guard.
+
+#define IPC_MESSAGE_START GpuMsgStart
+
+// Flag assigned to a video buffer for both input and output.
+#define kGpuVideoEndOfStream (1 << 0)
+
+IPC_STRUCT_BEGIN(GPUCreateCommandBufferConfig)
+  IPC_STRUCT_MEMBER(std::string, allowed_extensions)
+  IPC_STRUCT_MEMBER(std::vector<int>, attribs)
+IPC_STRUCT_END()
+
+IPC_STRUCT_BEGIN(GpuVideoDecoderInitParam)
+  IPC_STRUCT_MEMBER(int32, codec_id)
+  IPC_STRUCT_MEMBER(int32, width)
+  IPC_STRUCT_MEMBER(int32, height)
+  IPC_STRUCT_MEMBER(int32, profile)
+  IPC_STRUCT_MEMBER(int32, level)
+  IPC_STRUCT_MEMBER(int32, frame_rate_den)
+  IPC_STRUCT_MEMBER(int32, frame_rate_num)
+  IPC_STRUCT_MEMBER(int32, aspect_ratio_den)
+  IPC_STRUCT_MEMBER(int32, aspect_ratio_num)
+IPC_STRUCT_END()
+
+IPC_STRUCT_BEGIN(GpuVideoDecoderInitDoneParam)
+  // other parameter is only meaningful when this is true.
+  IPC_STRUCT_MEMBER(int32, success)
+  IPC_STRUCT_MEMBER(int32, input_buffer_size)
+  IPC_STRUCT_MEMBER(base::SharedMemoryHandle, input_buffer_handle)
+IPC_STRUCT_END()
+
+IPC_STRUCT_BEGIN(GpuVideoDecoderInputBufferParam)
+  IPC_STRUCT_MEMBER(int64, timestamp)  // In unit of microseconds.
+  IPC_STRUCT_MEMBER(int32, offset)
+  IPC_STRUCT_MEMBER(int32, size)
+  IPC_STRUCT_MEMBER(int32, flags)  // Miscellaneous flag bit mask.
+IPC_STRUCT_END()
+
+IPC_STRUCT_BEGIN(GpuVideoDecoderErrorInfoParam)
+  IPC_STRUCT_MEMBER(int32, error_id)  // TODO(jiesun): define enum.
+IPC_STRUCT_END()
+
+// TODO(jiesun): define this.
+IPC_STRUCT_BEGIN(GpuVideoDecoderFormatChangeParam)
+  IPC_STRUCT_MEMBER(int32, input_buffer_size)
+  IPC_STRUCT_MEMBER(base::SharedMemoryHandle, input_buffer_handle)
+IPC_STRUCT_END()
+
+#if defined(OS_MACOSX)
+IPC_STRUCT_BEGIN(GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params)
+  IPC_STRUCT_MEMBER(int32, renderer_id)
+  IPC_STRUCT_MEMBER(int32, render_view_id)
+  IPC_STRUCT_MEMBER(gfx::PluginWindowHandle, window)
+  IPC_STRUCT_MEMBER(int32, width)
+  IPC_STRUCT_MEMBER(int32, height)
+  IPC_STRUCT_MEMBER(uint64, identifier)
+IPC_STRUCT_END()
+
+IPC_STRUCT_BEGIN(GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params)
+  IPC_STRUCT_MEMBER(int32, renderer_id)
+  IPC_STRUCT_MEMBER(int32, render_view_id)
+  IPC_STRUCT_MEMBER(gfx::PluginWindowHandle, window)
+  IPC_STRUCT_MEMBER(uint64, surface_id)
+  IPC_STRUCT_MEMBER(int32, route_id)
+  IPC_STRUCT_MEMBER(uint64, swap_buffers_count)
+IPC_STRUCT_END()
+#endif
+
+IPC_STRUCT_TRAITS_BEGIN(DxDiagNode)
+  IPC_STRUCT_TRAITS_MEMBER(values)
+  IPC_STRUCT_TRAITS_MEMBER(children)
+IPC_STRUCT_TRAITS_END()
+
+IPC_ENUM_TRAITS(GPUInfo::Level)
+
+IPC_STRUCT_TRAITS_BEGIN(GPUInfo)
+  IPC_STRUCT_TRAITS_MEMBER(level)
+  IPC_STRUCT_TRAITS_MEMBER(initialization_time)
+  IPC_STRUCT_TRAITS_MEMBER(vendor_id)
+  IPC_STRUCT_TRAITS_MEMBER(device_id)
+  IPC_STRUCT_TRAITS_MEMBER(driver_vendor)
+  IPC_STRUCT_TRAITS_MEMBER(driver_version)
+  IPC_STRUCT_TRAITS_MEMBER(driver_date)
+  IPC_STRUCT_TRAITS_MEMBER(pixel_shader_version)
+  IPC_STRUCT_TRAITS_MEMBER(vertex_shader_version)
+  IPC_STRUCT_TRAITS_MEMBER(gl_version)
+  IPC_STRUCT_TRAITS_MEMBER(gl_version_string)
+  IPC_STRUCT_TRAITS_MEMBER(gl_vendor)
+  IPC_STRUCT_TRAITS_MEMBER(gl_renderer)
+  IPC_STRUCT_TRAITS_MEMBER(gl_extensions)
+  IPC_STRUCT_TRAITS_MEMBER(can_lose_context)
+  IPC_STRUCT_TRAITS_MEMBER(collection_error)
+#if defined(OS_WIN)
+  IPC_STRUCT_TRAITS_MEMBER(dx_diagnostics)
+#endif
+IPC_STRUCT_TRAITS_END()
+
+//------------------------------------------------------------------------------
+// GPU Messages
+// These are messages from the browser to the GPU process.
+
+// Tells the GPU process to initialize itself. The browser explicitly
+// requests this be done so that we are guaranteed that the channel is set
+// up between the browser and GPU process before doing any work that might
+// potentially crash the GPU process. Detection of the child process
+// exiting abruptly is predicated on having the IPC channel set up.
+IPC_MESSAGE_CONTROL0(GpuMsg_Initialize)
+
+// Tells the GPU process to create a new channel for communication with a
+// given renderer.  The channel name is returned in a
+// GpuHostMsg_ChannelEstablished message.  The renderer ID is passed so that
+// the GPU process reuses an existing channel to that process if it exists.
+// This ID is a unique opaque identifier generated by the browser process.
+IPC_MESSAGE_CONTROL1(GpuMsg_EstablishChannel,
+                     int /* renderer_id */)
+
+// Tells the GPU process to close the channel identified by IPC channel
+// handle.  If no channel can be identified, do nothing.
+IPC_MESSAGE_CONTROL1(GpuMsg_CloseChannel,
+                     IPC::ChannelHandle /* channel_handle */)
+
+// Provides a synchronization point to guarantee that the processing of
+// previous asynchronous messages (i.e., GpuMsg_EstablishChannel) has
+// completed. (This message can't be synchronous because the
+// GpuProcessHost uses an IPC::ChannelProxy, which sends all messages
+// asynchronously.) Results in a GpuHostMsg_SynchronizeReply.
+IPC_MESSAGE_CONTROL0(GpuMsg_Synchronize)
+
+// Tells the GPU process to create a new command buffer that renders directly
+// to a native view. A corresponding GpuCommandBufferStub is created.
+IPC_MESSAGE_CONTROL4(GpuMsg_CreateViewCommandBuffer,
+                     gfx::PluginWindowHandle, /* view */
+                     int32, /* render_view_id */
+                     int32, /* renderer_id */
+                     GPUCreateCommandBufferConfig /* init_params */)
+
+// Tells the GPU process to create a context for collecting graphics card
+// information.
+IPC_MESSAGE_CONTROL1(GpuMsg_CollectGraphicsInfo,
+                     GPUInfo::Level /* level */)
+
+#if defined(OS_MACOSX)
+// Tells the GPU process that the browser process handled the swap
+// buffers request with the given number. Note that it is possible
+// for the browser process to coalesce frames; it is not guaranteed
+// that every GpuHostMsg_AcceleratedSurfaceBuffersSwapped message
+// will result in a buffer swap on the browser side.
+IPC_MESSAGE_CONTROL3(GpuMsg_AcceleratedSurfaceBuffersSwappedACK,
+                     int /* renderer_id */,
+                     int32 /* route_id */,
+                     uint64 /* swap_buffers_count */)
+
+// Tells the GPU process that the IOSurface of the buffer belonging to
+// |renderer_route_id| a given id was destroyed, either by the user closing the
+// tab hosting the surface, or by the renderer navigating to a new page.
+IPC_MESSAGE_CONTROL2(GpuMsg_DidDestroyAcceleratedSurface,
+                     int /* renderer_id */,
+                     int32 /* renderer_route_id */)
+#endif
+
+// Tells the GPU process to crash.
+IPC_MESSAGE_CONTROL0(GpuMsg_Crash)
+
+// Tells the GPU process to hang.
+IPC_MESSAGE_CONTROL0(GpuMsg_Hang)
+
+// The browser sends this to a renderer process in response to a
+// GpuHostMsg_EstablishGpuChannel message.
+IPC_MESSAGE_CONTROL3(GpuMsg_GpuChannelEstablished,
+                     IPC::ChannelHandle /* handle to channel */,
+                     base::ProcessHandle /* renderer_process_for_gpu */,
+                     GPUInfo /* stats about GPU process*/)
+
+//------------------------------------------------------------------------------
+// GPU Host Messages
+// These are messages to the browser.
+
+// A renderer sends this when it wants to create a connection to the GPU
+// process. The browser will create the GPU process if necessary, and will
+// return a handle to the channel via a GpuChannelEstablished message.
+IPC_MESSAGE_CONTROL0(GpuHostMsg_EstablishGpuChannel)
+
+// A renderer sends this to the browser process to provide a synchronization
+// point for GPU operations, in particular to make sure the GPU channel has
+// been established.
+IPC_SYNC_MESSAGE_CONTROL0_0(GpuHostMsg_SynchronizeGpu)
+
+// A renderer sends this to the browser process when it wants to
+// create a GL context associated with the given view_id.
+IPC_SYNC_MESSAGE_CONTROL2_1(GpuHostMsg_CreateViewCommandBuffer,
+                            int32, /* render_view_id */
+                            GPUCreateCommandBufferConfig, /* init_params */
+                            int32 /* route_id */)
+
+// Response from GPU to a GpuHostMsg_EstablishChannel message.
+IPC_MESSAGE_CONTROL2(GpuHostMsg_ChannelEstablished,
+                     IPC::ChannelHandle, /* channel_handle */
+                     GPUInfo /* GPU logging stats */)
+
+// Respond from GPU to a GpuMsg_CreateViewCommandBuffer message.
+IPC_MESSAGE_CONTROL1(GpuHostMsg_CommandBufferCreated,
+                     int32 /* route_id */)
+
+// Request from GPU to free the browser resources associated with the
+// command buffer.
+IPC_MESSAGE_CONTROL3(GpuHostMsg_DestroyCommandBuffer,
+                     gfx::PluginWindowHandle, /* view */
+                     int32, /* render_view_id */
+                     int32 /* renderer_id */)
+
+// Response from GPU to a GpuMsg_CollectGraphicsInfo.
+IPC_MESSAGE_CONTROL1(GpuHostMsg_GraphicsInfoCollected,
+                     GPUInfo /* GPU logging stats */)
+
+// Message from GPU to add a GPU log message to the about:gpu page.
+IPC_MESSAGE_CONTROL3(GpuHostMsg_OnLogMessage,
+                     int /*severity*/,
+                     std::string /* header */,
+                     std::string /* message */)
+
+// Response from GPU to a GpuMsg_Synchronize message.
+IPC_MESSAGE_CONTROL0(GpuHostMsg_SynchronizeReply)
+
+#if defined(OS_LINUX) && !defined(TOUCH_UI)
+// Resize the window that is being drawn into. It's important that this
+// resize be synchronized with the swapping of the front and back buffers.
+IPC_SYNC_MESSAGE_CONTROL2_1(GpuHostMsg_ResizeXID,
+                            unsigned long, /* xid */
+                            gfx::Size, /* size */
+                            bool /* success */)
+#elif defined(OS_MACOSX)
+// This message, used on Mac OS X 10.6 and later (where IOSurface is
+// supported), is sent from the GPU process to the browser to indicate that a
+// new backing store was allocated for the given "window" (fake
+// PluginWindowHandle). The renderer ID and render view ID are needed in
+// order to uniquely identify the RenderWidgetHostView on the browser side.
+IPC_MESSAGE_CONTROL1(GpuHostMsg_AcceleratedSurfaceSetIOSurface,
+                     GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params)
+
+// This message notifies the browser process that the renderer
+// swapped the buffers associated with the given "window", which
+// should cause the browser to redraw the compositor's contents.
+IPC_MESSAGE_CONTROL1(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
+                     GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params)
+#elif defined(OS_WIN)
+IPC_MESSAGE_CONTROL2(GpuHostMsg_ScheduleComposite,
+                     int32, /* renderer_id */
+                     int32 /* render_view_id */)
+#endif
+
+//------------------------------------------------------------------------------
+// GPU Channel Messages
+// These are messages from a renderer process to the GPU process.
+
+// Initialize a channel between a renderer process and a GPU process. The
+// renderer passes its process handle to the GPU process, which gives gives the
+// GPU process the ability to map handles from the renderer process. This must
+// be the first message sent on a newly connected channel.
+IPC_MESSAGE_CONTROL1(GpuChannelMsg_Initialize,
+                     base::ProcessHandle /* renderer_process_for_gpu */)
+
+// Tells the GPU process to create a new command buffer that renders to an
+// offscreen frame buffer. If parent_route_id is not zero, the texture backing
+// the frame buffer is mapped into the corresponding parent command buffer's
+// namespace, with the name of parent_texture_id. This ID is in the parent's
+// namespace.
+IPC_SYNC_MESSAGE_CONTROL4_1(GpuChannelMsg_CreateOffscreenCommandBuffer,
+                            int32, /* parent_route_id */
+                            gfx::Size, /* size */
+                            GPUCreateCommandBufferConfig, /* init_params */
+                            uint32, /* parent_texture_id */
+                            int32 /* route_id */)
+
+// The CommandBufferProxy sends this to the GpuCommandBufferStub in its
+// destructor, so that the stub deletes the actual CommandBufferService
+// object that it's hosting.
+// TODO(apatrick): Implement this.
+IPC_SYNC_MESSAGE_CONTROL1_0(GpuChannelMsg_DestroyCommandBuffer,
+                            int32 /* instance_id */)
+
+// Create hardware video decoder && associate it with the output |decoder_id|;
+// We need this to be control message because we had to map the GpuChannel and
+// |decoder_id|.
+IPC_MESSAGE_CONTROL2(GpuChannelMsg_CreateVideoDecoder,
+                     int32, /* context_route_id */
+                     int32) /* decoder_id */
+
+// Release all resource of the hardware video decoder which was assocaited
+// with the input |decoder_id|.
+// TODO(hclam): This message needs to be asynchronous.
+IPC_SYNC_MESSAGE_CONTROL1_0(GpuChannelMsg_DestroyVideoDecoder,
+                            int32 /* decoder_id */)
+
+//------------------------------------------------------------------------------
+// GPU Command Buffer Messages
+// These are messages between a renderer process to the GPU process relating to
+// a single OpenGL context.
+// Initialize a command buffer with the given number of command entries.
+// Returns the shared memory handle for the command buffer mapped to the
+// calling process.
+IPC_SYNC_MESSAGE_ROUTED2_1(GpuCommandBufferMsg_Initialize,
+                           base::SharedMemoryHandle /* ring_buffer */,
+                           int32 /* size */,
+                           bool /* result */)
+
+// Get the current state of the command buffer.
+IPC_SYNC_MESSAGE_ROUTED0_1(GpuCommandBufferMsg_GetState,
+                           gpu::CommandBuffer::State /* state */)
+
+// Get the current state of the command buffer asynchronously. State is
+// returned via UpdateState message.
+IPC_MESSAGE_ROUTED0(GpuCommandBufferMsg_AsyncGetState)
+
+// Synchronize the put and get offsets of both processes. Caller passes its
+// current put offset. Current state (including get offset) is returned.
+IPC_SYNC_MESSAGE_ROUTED1_1(GpuCommandBufferMsg_Flush,
+                           int32 /* put_offset */,
+                           gpu::CommandBuffer::State /* state */)
+
+// Asynchronously synchronize the put and get offsets of both processes.
+// Caller passes its current put offset. Current state (including get offset)
+// is returned via an UpdateState message.
+IPC_MESSAGE_ROUTED1(GpuCommandBufferMsg_AsyncFlush,
+                    int32 /* put_offset */)
+
+// Return the current state of the command buffer following a request via
+// an AsyncGetState or AsyncFlush message. (This message is sent from the
+// GPU process to the renderer process.)
+IPC_MESSAGE_ROUTED1(GpuCommandBufferMsg_UpdateState,
+                    gpu::CommandBuffer::State /* state */)
+
+// Indicates that a SwapBuffers call has been issued.
+IPC_MESSAGE_ROUTED0(GpuCommandBufferMsg_SwapBuffers)
+
+// Create a shared memory transfer buffer. Returns an id that can be used to
+// identify the transfer buffer from a comment.
+IPC_SYNC_MESSAGE_ROUTED1_1(GpuCommandBufferMsg_CreateTransferBuffer,
+                           int32 /* size */,
+                           int32 /* id */)
+
+// Register an existing shared memory transfer buffer. Returns an id that can be
+// used to identify the transfer buffer from a command buffer.
+IPC_SYNC_MESSAGE_ROUTED2_1(GpuCommandBufferMsg_RegisterTransferBuffer,
+                           base::SharedMemoryHandle /* transfer_buffer */,
+                           size_t /* size */,
+                           int32 /* id */)
+
+// Destroy a previously created transfer buffer.
+IPC_SYNC_MESSAGE_ROUTED1_0(GpuCommandBufferMsg_DestroyTransferBuffer,
+                           int32 /* id */)
+
+// Get the shared memory handle for a transfer buffer mapped to the callers
+// process.
+IPC_SYNC_MESSAGE_ROUTED1_2(GpuCommandBufferMsg_GetTransferBuffer,
+                           int32 /* id */,
+                           base::SharedMemoryHandle /* transfer_buffer */,
+                           uint32 /* size */)
+
+// Send from command buffer stub to proxy when window is invalid and must be
+// repainted.
+IPC_MESSAGE_ROUTED0(GpuCommandBufferMsg_NotifyRepaint)
+
+// Tells the GPU process to resize an offscreen frame buffer.
+IPC_MESSAGE_ROUTED1(GpuCommandBufferMsg_ResizeOffscreenFrameBuffer,
+                    gfx::Size /* size */)
+
+#if defined(OS_MACOSX)
+// On Mac OS X the GPU plugin must be offscreen, because there is no
+// true cross-process window hierarchy. For this reason we must send
+// resize events explicitly to the command buffer stub so it can
+// reallocate its backing store and send the new one back to the
+// browser. This message is currently used only on 10.6 and later.
+IPC_MESSAGE_ROUTED1(GpuCommandBufferMsg_SetWindowSize,
+                    gfx::Size /* size */)
+#endif
+
+//------------------------------------------------------------------------------
+// GPU Video Decoder Messages
+// These messages are sent from Renderer process to GPU process.
+// Initialize and configure GpuVideoDecoder asynchronously.
+IPC_MESSAGE_ROUTED1(GpuVideoDecoderMsg_Initialize,
+                    GpuVideoDecoderInitParam)
+
+// Destroy and release GpuVideoDecoder asynchronously.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderMsg_Destroy)
+
+// Start decoder flushing operation.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderMsg_Flush)
+
+// Tell the decoder to start prerolling.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderMsg_Preroll)
+
+// Send input buffer to GpuVideoDecoder.
+IPC_MESSAGE_ROUTED1(GpuVideoDecoderMsg_EmptyThisBuffer,
+                    GpuVideoDecoderInputBufferParam)
+
+// Ask the GPU process to produce a video frame with the ID.
+IPC_MESSAGE_ROUTED1(GpuVideoDecoderMsg_ProduceVideoFrame,
+                    int32) /* Video Frame ID */
+
+// Sent from Renderer process to the GPU process to notify that textures are
+// generated for a video frame.
+IPC_MESSAGE_ROUTED2(GpuVideoDecoderMsg_VideoFrameAllocated,
+                    int32, /* Video Frame ID */
+                    std::vector<uint32>) /* Textures for video frame */
+
+//------------------------------------------------------------------------------
+// GPU Video Decoder Host Messages
+// These messages are sent from GPU process to Renderer process.
+// Inform GpuVideoDecoderHost that a GpuVideoDecoder is created.
+IPC_MESSAGE_ROUTED1(GpuVideoDecoderHostMsg_CreateVideoDecoderDone,
+                    int32) /* decoder_id */
+
+// Confirm GpuVideoDecoder had been initialized or failed to initialize.
+// TODO(hclam): Change this to Done instead of ACK.
+IPC_MESSAGE_ROUTED1(GpuVideoDecoderHostMsg_InitializeACK,
+                    GpuVideoDecoderInitDoneParam)
+
+// Confrim GpuVideoDecoder had been destroyed properly.
+// TODO(hclam): Change this to Done instead of ACK.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderHostMsg_DestroyACK)
+
+// Confirm decoder had been flushed.
+// TODO(hclam): Change this to Done instead of ACK.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderHostMsg_FlushACK)
+
+// Confirm preroll operation is done.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderHostMsg_PrerollDone)
+
+// GpuVideoDecoder has consumed input buffer from transfer buffer.
+// TODO(hclam): Change this to Done instead of ACK.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderHostMsg_EmptyThisBufferACK)
+
+// GpuVideoDecoder require new input buffer.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderHostMsg_EmptyThisBufferDone)
+
+// GpuVideoDecoder reports that a video frame is ready to be consumed.
+IPC_MESSAGE_ROUTED4(GpuVideoDecoderHostMsg_ConsumeVideoFrame,
+                    int32, /* Video Frame ID */
+                    int64, /* Timestamp in microseconds */
+                    int64, /* Duration in microseconds */
+                    int32) /* Flags */
+
+// Allocate video frames for output of the hardware video decoder.
+IPC_MESSAGE_ROUTED4(GpuVideoDecoderHostMsg_AllocateVideoFrames,
+                    int32,  /* Number of video frames to generate */
+                    uint32, /* Width of the video frame */
+                    uint32, /* Height of the video frame */
+                    int32   /* Format of the video frame */)
+
+// Release all video frames allocated for a hardware video decoder.
+IPC_MESSAGE_ROUTED0(GpuVideoDecoderHostMsg_ReleaseAllVideoFrames)
+
+// GpuVideoDecoder report output format change.
+IPC_MESSAGE_ROUTED1(GpuVideoDecoderHostMsg_MediaFormatChange,
+                    GpuVideoDecoderFormatChangeParam)
+
+// GpuVideoDecoder report error.
+IPC_MESSAGE_ROUTED1(GpuVideoDecoderHostMsg_ErrorNotification,
+                    GpuVideoDecoderErrorInfoParam)
diff --git a/content/content_common.gypi b/content/content_common.gypi
index a3d382a..fa83cf9 100644
--- a/content/content_common.gypi
+++ b/content/content_common.gypi
@@ -36,6 +36,8 @@
         'common/content_paths.h',
         'common/content_switches.cc',
         'common/content_switches.h',
+        'common/dx_diag_node.cc',
+        'common/dx_diag_node.h',
         'common/file_system/file_system_dispatcher.cc',
         'common/file_system/file_system_dispatcher.h',
         'common/file_system/webfilesystem_callback_dispatcher.cc',
@@ -45,6 +47,9 @@
         'common/file_system/webfilewriter_impl.cc',
         'common/file_system/webfilewriter_impl.h',
         'common/file_system_messages.h',
+        'common/gpu_info.cc',
+        'common/gpu_info.h',
+        'common/gpu_messages.h',
         'common/message_router.cc',
         'common/message_router.h',
         'common/notification_details.cc',