Move chrome\gpu to content\gpu.

TBR=avi
Review URL: http://codereview.chromium.org/6684015

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

40 files changed, 10 insertions, 4771 deletions

diff --git a/chrome/browser/gpu_data_manager.cc b/chrome/browser/gpu_data_manager.cc
index 8b7274e..2e0a478 100644
--- a/chrome/browser/gpu_data_manager.cc
+++ b/chrome/browser/gpu_data_manager.cc
@@ -15,8 +15,8 @@
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
-#include "chrome/gpu/gpu_info_collector.h"
 #include "content/browser/gpu_blacklist.h"
+#include "content/gpu/gpu_info_collector.h"
 #include "grit/browser_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
diff --git a/chrome/chrome.gyp b/chrome/chrome.gyp
index daaab35..39a6265 100644
--- a/chrome/chrome.gyp
+++ b/chrome/chrome.gyp
@@ -23,7 +23,6 @@
     'chromium_dependencies': [
       'common',
       'browser',
-      'chrome_gpu',
       'ppapi_plugin',
       'profile_import',
       'renderer',
@@ -31,6 +30,7 @@
       'utility',
       'worker',
       'service',
+      '../content/content.gyp:content_gpu',
       '../printing/printing.gyp:printing',
       '../third_party/WebKit/Source/WebKit/chromium/WebKit.gyp:inspector_resources',
     ],
@@ -71,7 +71,6 @@
     'repack_locales_cmd': ['python', 'tools/build/repack_locales.py'],
     # TODO: remove this helper when we have loops in GYP
     'apply_locales_cmd': ['python', '<(DEPTH)/build/apply_locales.py'],
-    'directxsdk_exists': '<!(python <(DEPTH)/build/dir_exists.py ../third_party/directxsdk)',
     'conditions': [
       ['OS=="win"', {
         'nacl_defines': [
@@ -643,123 +642,6 @@
       ],
     },
     {
-      'target_name': 'chrome_gpu',
-      'type': '<(library)',
-      'msvs_guid': 'F10F1ECD-D84D-4C33-8468-9DDFE19F4D8A',
-      'dependencies': [
-        '../app/app.gyp:app_base',
-        '../base/base.gyp:base',
-        'common',
-        '../media/media.gyp:media',
-        '../skia/skia.gyp:skia',
-      ],
-      'sources': [
-        'gpu/gpu_channel.cc',
-        'gpu/gpu_channel.h',
-        'gpu/gpu_command_buffer_stub.cc',
-        'gpu/gpu_command_buffer_stub.h',
-        'gpu/gpu_config.h',
-        'gpu/gpu_dx_diagnostics_win.cc',
-        'gpu/gpu_info_collector_linux.cc',
-        'gpu/gpu_info_collector_mac.mm',
-        'gpu/gpu_info_collector_win.cc',
-        'gpu/gpu_info_collector.cc',
-        'gpu/gpu_info_collector.h',
-        'gpu/gpu_main.cc',
-        'gpu/gpu_process.cc',
-        'gpu/gpu_process.h',
-        'gpu/gpu_thread.cc',
-        'gpu/gpu_thread.h',
-        'gpu/gpu_video_decoder.cc',
-        'gpu/gpu_video_decoder.h',
-        'gpu/gpu_video_service.cc',
-        'gpu/gpu_video_service.h',
-        'gpu/gpu_watchdog_thread.cc',
-        'gpu/gpu_watchdog_thread.h',
-        'gpu/media/gpu_video_device.h',
-        'gpu/media/fake_gl_video_decode_engine.cc',
-        'gpu/media/fake_gl_video_decode_engine.h',
-        'gpu/media/fake_gl_video_device.cc',
-        'gpu/media/fake_gl_video_device.h',
-      ],
-      'include_dirs': [
-        '..',
-      ],
-      'conditions': [
-        ['OS=="win"', {
-          'include_dirs': [
-            '<(DEPTH)/third_party/angle/include',
-            '<(DEPTH)/third_party/angle/src',
-            '<(DEPTH)/third_party/wtl/include',
-            '$(DXSDK_DIR)/include',
-          ],
-          'dependencies': [
-            '../third_party/angle/src/build_angle.gyp:libEGL',
-            '../third_party/angle/src/build_angle.gyp:libGLESv2',
-          ],
-        }],
-        ['OS=="win" and directxsdk_exists=="True"', {
-          'actions': [
-            {
-              'action_name': 'extract_d3dx9',
-              'variables': {
-                'input': 'Aug2009_d3dx9_42_x86.cab',
-                'output': 'd3dx9_42.dll',
-              },
-              'inputs': [
-                '../third_party/directxsdk/files/Redist/<(input)',
-              ],
-              'outputs': [
-                '<(PRODUCT_DIR)/<(output)',
-              ],
-              'action': [
-                'python',
-                '../build/extract_from_cab.py',
-                '..\\third_party\\directxsdk\\files\\Redist\\<(input)',
-                '<(output)',
-                '<(PRODUCT_DIR)',
-              ],
-            },
-            {
-              'action_name': 'extract_d3dcompiler',
-              'variables': {
-                'input': 'Aug2009_D3DCompiler_42_x86.cab',
-                'output': 'D3DCompiler_42.dll',
-              },
-              'inputs': [
-                '../third_party/directxsdk/files/Redist/<(input)',
-              ],
-              'outputs': [
-                '<(PRODUCT_DIR)/<(output)',
-              ],
-              'action': [
-                'python',
-                '../build/extract_from_cab.py',
-                '..\\third_party\\directxsdk\\files\\Redist\\<(input)',
-                '<(output)',
-                '<(PRODUCT_DIR)',
-              ],
-            },
-          ],
-          'sources': [
-            'gpu/media/mft_angle_video_device.cc',
-            'gpu/media/mft_angle_video_device.h',
-          ],
-        }],
-        ['OS=="linux" and target_arch!="arm"', {
-          'sources': [
-            'gpu/x_util.cc',
-            'gpu/x_util.h',
-          ],
-        }],
-        ['enable_gpu==1', {
-          'dependencies': [
-            '../gpu/gpu.gyp:command_buffer_service',
-          ],
-        }],
-      ],
-    },
-    {
       'target_name': 'ppapi_plugin',
       'type': '<(library)',
       'dependencies': [
diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi
index 9073e09..5e8ff4d 100644
--- a/chrome/chrome_tests.gypi
+++ b/chrome/chrome_tests.gypi
@@ -26,13 +26,13 @@
         'browser',
         'common',
         'renderer',
-        'chrome_gpu',
         'chrome_resources',
         'chrome_strings',
         'app/policy/cloud_policy_codegen.gyp:policy',
         'browser/sync/protocol/sync_proto.gyp:sync_proto_cpp',
         'theme_resources',
         '../base/base.gyp:test_support_base',
+        '../content/content.gyp:content_gpu',
         '../ipc/ipc.gyp:test_support_ipc',
         '../media/media.gyp:media_test_support',
         # 'test/test_url_request_context_getter.h' brings in this requirement.
@@ -1089,7 +1089,6 @@
         'browser',
         'browser/sync/protocol/sync_proto.gyp:sync_proto_cpp',
         'chrome',
-        'chrome_gpu',
         'chrome_resources',
         'chrome_strings',
         'common',
@@ -1102,6 +1101,7 @@
         'utility',
         '../app/app.gyp:app_base',
         '../app/app.gyp:app_resources',
+        '../content/content.gyp:content_gpu',
         '../gpu/gpu.gyp:gpu_unittest_utils',
         '../ipc/ipc.gyp:ipc',
         '../media/media.gyp:media_test_support',
@@ -1753,11 +1753,6 @@
         'common/web_apps_unittest.cc',
         'common/worker_thread_ticker_unittest.cc',
         'common/zip_unittest.cc',
-        'gpu/gpu_idirect3d9_mock_win.cc',
-        'gpu/gpu_idirect3d9_mock_win.h',
-        'gpu/gpu_info_collector_unittest.cc',
-        'gpu/gpu_info_unittest_win.cc',
-        'gpu/gpu_video_decoder_unittest.cc',
         'renderer/audio_message_filter_unittest.cc',
         'renderer/extensions/extension_api_json_validity_unittest.cc',
         'renderer/extensions/json_schema_unittest.cc',
@@ -1842,6 +1837,11 @@
         '../content/common/sandbox_mac_unittest_helper.h',
         '../content/common/sandbox_mac_unittest_helper.mm',
         '../content/common/sandbox_mac_system_access_unittest.mm',
+        '../content/gpu/gpu_idirect3d9_mock_win.cc',
+        '../content/gpu/gpu_idirect3d9_mock_win.h',
+        '../content/gpu/gpu_info_collector_unittest.cc',
+        '../content/gpu/gpu_info_unittest_win.cc',
+        '../content/gpu/gpu_video_decoder_unittest.cc',
         '../testing/gtest_mac_unittest.mm',
         '../third_party/cld/encodings/compact_lang_det/compact_lang_det_unittest_small.cc',
         '../webkit/fileapi/file_system_dir_url_request_job_unittest.cc',
@@ -3277,10 +3277,10 @@
             'browser',
             'common',
             'renderer',
-            'chrome_gpu',
             'chrome_resources',
             'chrome_strings',
             '../app/app.gyp:app_base',
+            '../content/content.gyp:content_gpu',
             '../base/base.gyp:base',
             '../base/base.gyp:test_support_base',
             '../base/base.gyp:test_support_perf',
diff --git a/chrome/gpu/DEPS b/chrome/gpu/DEPS
deleted file mode 100644
index 66112a0..0000000
--- a/chrome/gpu/DEPS
+++ /dev/null
@@ -1,10 +0,0 @@
-include_rules = [

-  "+chrome/app",

-  "+gpu/command_buffer",

-  "+libEGL",

-  "+libGLESv2",

-  "+media/base",

-  "+media/video",

-  "+sandbox",

-  "+skia",

-]

diff --git a/chrome/gpu/gpu_channel.cc b/chrome/gpu/gpu_channel.cc
deleted file mode 100644
index 8b1e1d2..0000000
--- a/chrome/gpu/gpu_channel.cc
+++ /dev/null
@@ -1,260 +0,0 @@
-// 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.
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
-#include "chrome/gpu/gpu_channel.h"
-
-#include "base/command_line.h"
-#include "base/process_util.h"
-#include "base/string_util.h"
-#include "chrome/gpu/gpu_thread.h"
-#include "chrome/gpu/gpu_video_service.h"
-#include "content/common/child_process.h"
-#include "content/common/content_switches.h"
-#include "content/common/gpu_messages.h"
-
-#if defined(OS_POSIX)
-#include "ipc/ipc_channel_posix.h"
-#endif
-
-GpuChannel::GpuChannel(GpuThread* gpu_thread,
-                       int renderer_id)
-    : gpu_thread_(gpu_thread),
-      renderer_id_(renderer_id),
-      renderer_process_(NULL),
-      renderer_pid_(NULL) {
-  DCHECK(gpu_thread);
-  DCHECK(renderer_id);
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
-}
-
-GpuChannel::~GpuChannel() {
-#if defined(OS_WIN)
-  if (renderer_process_)
-    CloseHandle(renderer_process_);
-#endif
-}
-
-bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
-  if (log_messages_) {
-    VLOG(1) << "received message @" << &message << " on channel @" << this
-            << " with type " << message.type();
-  }
-
-  if (message.routing_id() == MSG_ROUTING_CONTROL)
-    return OnControlMessageReceived(message);
-
-  if (!router_.RouteMessage(message)) {
-    // Respond to sync messages even if router failed to route.
-    if (message.is_sync()) {
-      IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
-      reply->set_reply_error();
-      Send(reply);
-    }
-    return false;
-  }
-
-  return true;
-}
-
-void GpuChannel::OnChannelError() {
-  gpu_thread_->RemoveChannel(renderer_id_);
-}
-
-void GpuChannel::OnChannelConnected(int32 peer_pid) {
-  renderer_pid_ = peer_pid;
-}
-
-bool GpuChannel::Send(IPC::Message* message) {
-  if (log_messages_) {
-    VLOG(1) << "sending message @" << message << " on channel @" << this
-            << " with type " << message->type();
-  }
-
-  if (!channel_.get()) {
-    delete message;
-    return false;
-  }
-
-  return channel_->Send(message);
-}
-
-void GpuChannel::CreateViewCommandBuffer(
-    gfx::PluginWindowHandle window,
-    int32 render_view_id,
-    const GPUCreateCommandBufferConfig& init_params,
-    int32* route_id) {
-  *route_id = MSG_ROUTING_NONE;
-
-#if defined(ENABLE_GPU)
-  *route_id = GenerateRouteID();
-  scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
-      this, window, NULL, gfx::Size(), init_params.allowed_extensions,
-      init_params.attribs, 0, *route_id, renderer_id_, render_view_id));
-  router_.AddRoute(*route_id, stub.get());
-  stubs_.AddWithID(stub.release(), *route_id);
-#endif  // ENABLE_GPU
-}
-
-#if defined(OS_MACOSX)
-void GpuChannel::AcceleratedSurfaceBuffersSwapped(
-    int32 route_id, uint64 swap_buffers_count) {
-  GpuCommandBufferStub* stub = stubs_.Lookup(route_id);
-  if (stub == NULL)
-    return;
-  stub->AcceleratedSurfaceBuffersSwapped(swap_buffers_count);
-}
-
-void GpuChannel::DidDestroySurface(int32 renderer_route_id) {
-  // Since acclerated views are created in the renderer process and then sent
-  // to the browser process during GPU channel construction, it is possible that
-  // this is called before a GpuCommandBufferStub for |renderer_route_id| was
-  // put into |stubs_|. Hence, do not walk |stubs_| here but instead remember
-  // all |renderer_route_id|s this was called for and use them later.
-  destroyed_renderer_routes_.insert(renderer_route_id);
-}
-
-bool GpuChannel::IsRenderViewGone(int32 renderer_route_id) {
-  return destroyed_renderer_routes_.count(renderer_route_id) > 0;
-}
-#endif
-
-bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
-    IPC_MESSAGE_HANDLER(GpuChannelMsg_Initialize, OnInitialize)
-    IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateOffscreenCommandBuffer,
-        OnCreateOffscreenCommandBuffer)
-    IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
-        OnDestroyCommandBuffer)
-    IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateVideoDecoder,
-        OnCreateVideoDecoder)
-    IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyVideoDecoder,
-        OnDestroyVideoDecoder)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  DCHECK(handled);
-  return handled;
-}
-
-int GpuChannel::GenerateRouteID() {
-  static int last_id = 0;
-  return ++last_id;
-}
-
-void GpuChannel::OnInitialize(base::ProcessHandle renderer_process) {
-  // Initialize should only happen once.
-  DCHECK(!renderer_process_);
-
-  // Verify that the renderer has passed its own process handle.
-  if (base::GetProcId(renderer_process) == renderer_pid_)
-    renderer_process_ = renderer_process;
-}
-
-void GpuChannel::OnCreateOffscreenCommandBuffer(
-    int32 parent_route_id,
-    const gfx::Size& size,
-    const GPUCreateCommandBufferConfig& init_params,
-    uint32 parent_texture_id,
-    int32* route_id) {
-#if defined(ENABLE_GPU)
-  *route_id = GenerateRouteID();
-  GpuCommandBufferStub* parent_stub = NULL;
-  if (parent_route_id != 0)
-    parent_stub = stubs_.Lookup(parent_route_id);
-
-  scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
-      this,
-      gfx::kNullPluginWindow,
-      parent_stub,
-      size,
-      init_params.allowed_extensions,
-      init_params.attribs,
-      parent_texture_id,
-      *route_id,
-      0, 0));
-  router_.AddRoute(*route_id, stub.get());
-  stubs_.AddWithID(stub.release(), *route_id);
-#else
-  *route_id = MSG_ROUTING_NONE;
-#endif
-}
-
-void GpuChannel::OnDestroyCommandBuffer(int32 route_id) {
-#if defined(ENABLE_GPU)
-  if (router_.ResolveRoute(route_id)) {
-    router_.RemoveRoute(route_id);
-    stubs_.Remove(route_id);
-  }
-#endif
-}
-
-void GpuChannel::OnCreateVideoDecoder(int32 context_route_id,
-                                      int32 decoder_host_id) {
-// TODO(cevans): do NOT re-enable this until GpuVideoService has been checked
-// for integer overflows, including the classic "width * height" overflow.
-#if 0
-  VLOG(1) << "GpuChannel::OnCreateVideoDecoder";
-  GpuVideoService* service = GpuVideoService::GetInstance();
-  if (service == NULL) {
-    // TODO(hclam): Need to send a failure message.
-    return;
-  }
-
-  // The context ID corresponds to the command buffer used.
-  GpuCommandBufferStub* stub = stubs_.Lookup(context_route_id);
-  int32 decoder_id = GenerateRouteID();
-
-  // TODO(hclam): Need to be careful about the lifetime of the command buffer
-  // decoder.
-  bool ret = service->CreateVideoDecoder(
-      this, &router_, decoder_host_id, decoder_id,
-      stub->processor()->decoder());
-  DCHECK(ret) << "Failed to create a GpuVideoDecoder";
-#endif
-}
-
-void GpuChannel::OnDestroyVideoDecoder(int32 decoder_id) {
-#if defined(ENABLE_GPU)
-  LOG(ERROR) << "GpuChannel::OnDestroyVideoDecoder";
-  GpuVideoService* service = GpuVideoService::GetInstance();
-  if (service == NULL)
-    return;
-  service->DestroyVideoDecoder(&router_, decoder_id);
-#endif
-}
-
-bool GpuChannel::Init() {
-  // Check whether we're already initialized.
-  if (channel_.get())
-    return true;
-
-  // Map renderer ID to a (single) channel to that process.
-  std::string channel_name = GetChannelName();
-  channel_.reset(new IPC::SyncChannel(
-      channel_name, IPC::Channel::MODE_SERVER, this,
-      ChildProcess::current()->io_message_loop(), false,
-      ChildProcess::current()->GetShutDownEvent()));
-
-  return true;
-}
-
-std::string GpuChannel::GetChannelName() {
-  return StringPrintf("%d.r%d.gpu", base::GetCurrentProcId(), renderer_id_);
-}
-
-#if defined(OS_POSIX)
-int GpuChannel::GetRendererFileDescriptor() {
-  int fd = -1;
-  if (channel_.get()) {
-    fd = channel_->GetClientFileDescriptor();
-  }
-  return fd;
-}
-#endif  // defined(OS_POSIX)
-
diff --git a/chrome/gpu/gpu_channel.h b/chrome/gpu/gpu_channel.h
deleted file mode 100644
index 2512104..0000000
--- a/chrome/gpu/gpu_channel.h
+++ /dev/null
@@ -1,127 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_GPU_CHANNEL_H_
-#define CHROME_GPU_GPU_CHANNEL_H_
-#pragma once
-
-#include <set>
-#include <string>
-#include <vector>
-
-#include "base/id_map.h"
-#include "base/process.h"
-#include "base/scoped_ptr.h"
-#include "build/build_config.h"
-#include "chrome/gpu/gpu_command_buffer_stub.h"
-#include "content/common/message_router.h"
-#include "ipc/ipc_sync_channel.h"
-#include "ui/gfx/native_widget_types.h"
-#include "ui/gfx/size.h"
-
-class GpuThread;
-struct GPUCreateCommandBufferConfig;
-
-// Encapsulates an IPC channel between the GPU process and one renderer
-// process. On the renderer side there's a corresponding GpuChannelHost.
-class GpuChannel : public IPC::Channel::Listener,
-                   public IPC::Message::Sender,
-                   public base::RefCountedThreadSafe<GpuChannel> {
- public:
-  // Takes ownership of the renderer process handle.
-  GpuChannel(GpuThread* gpu_thread,
-             int renderer_id);
-  virtual ~GpuChannel();
-
-  bool Init();
-
-  // Get the GpuThread that owns this channel.
-  GpuThread* gpu_thread() const { return gpu_thread_; }
-
-  // Returns the name of the associated IPC channel.
-  std::string GetChannelName();
-
-#if defined(OS_POSIX)
-  int GetRendererFileDescriptor();
-#endif  // defined(OS_POSIX)
-
-  base::ProcessHandle renderer_process() const {
-    return renderer_process_;
-  }
-
-  // IPC::Channel::Listener implementation:
-  virtual bool OnMessageReceived(const IPC::Message& msg);
-  virtual void OnChannelError();
-  virtual void OnChannelConnected(int32 peer_pid);
-
-  // IPC::Message::Sender implementation:
-  virtual bool Send(IPC::Message* msg);
-
-  void CreateViewCommandBuffer(
-      gfx::PluginWindowHandle window,
-      int32 render_view_id,
-      const GPUCreateCommandBufferConfig& init_params,
-      int32* route_id);
-
-#if defined(OS_MACOSX)
-  virtual void AcceleratedSurfaceBuffersSwapped(
-      int32 route_id, uint64 swap_buffers_count);
-  void DidDestroySurface(int32 renderer_route_id);
-
-  bool IsRenderViewGone(int32 renderer_route_id);
-#endif
-
- private:
-  bool OnControlMessageReceived(const IPC::Message& msg);
-
-  int GenerateRouteID();
-
-  // Message handlers.
-  void OnInitialize(base::ProcessHandle renderer_process);
-  void OnCreateOffscreenCommandBuffer(
-      int32 parent_route_id,
-      const gfx::Size& size,
-      const GPUCreateCommandBufferConfig& init_params,
-      uint32 parent_texture_id,
-      int32* route_id);
-  void OnDestroyCommandBuffer(int32 route_id);
-
-  void OnCreateVideoDecoder(int32 context_route_id,
-                            int32 decoder_host_id);
-  void OnDestroyVideoDecoder(int32 decoder_id);
-
-  // The lifetime of objects of this class is managed by a GpuThread. The
-  // GpuThreadss destroy all the GpuChannels that they own when they
-  // are destroyed. So a raw pointer is safe.
-  GpuThread* gpu_thread_;
-
-  scoped_ptr<IPC::SyncChannel> channel_;
-
-  // The id of the renderer who is on the other side of the channel.
-  int renderer_id_;
-
-  // Handle to the renderer process that is on the other side of the channel.
-  base::ProcessHandle renderer_process_;
-
-  // The process id of the renderer process.
-  base::ProcessId renderer_pid_;
-
-  // Used to implement message routing functionality to CommandBuffer objects
-  MessageRouter router_;
-
-#if defined(ENABLE_GPU)
-  typedef IDMap<GpuCommandBufferStub, IDMapOwnPointer> StubMap;
-  StubMap stubs_;
-
-#if defined(OS_MACOSX)
-  std::set<int32> destroyed_renderer_routes_;
-#endif  // defined (OS_MACOSX)
-#endif  // defined (ENABLE_GPU)
-
-  bool log_messages_;  // True if we should log sent and received messages.
-
-  DISALLOW_COPY_AND_ASSIGN(GpuChannel);
-};
-
-#endif  // CHROME_GPU_GPU_CHANNEL_H_
diff --git a/chrome/gpu/gpu_command_buffer_stub.cc b/chrome/gpu/gpu_command_buffer_stub.cc
deleted file mode 100644
index 17a9235..0000000
--- a/chrome/gpu/gpu_command_buffer_stub.cc
+++ /dev/null
@@ -1,416 +0,0 @@
-// 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.
-
-#if defined(ENABLE_GPU)
-
-#include "base/process_util.h"
-#include "base/shared_memory.h"
-#include "build/build_config.h"
-#include "chrome/gpu/gpu_channel.h"
-#include "chrome/gpu/gpu_command_buffer_stub.h"
-#include "chrome/gpu/gpu_thread.h"
-#include "content/common/child_thread.h"
-#include "content/common/gpu_messages.h"
-
-using gpu::Buffer;
-
-#if defined(OS_WIN)
-#define kCompositorWindowOwner L"CompositorWindowOwner"
-#endif  // defined(OS_WIN)
-
-GpuCommandBufferStub::GpuCommandBufferStub(
-    GpuChannel* channel,
-    gfx::PluginWindowHandle handle,
-    GpuCommandBufferStub* parent,
-    const gfx::Size& size,
-    const std::string& allowed_extensions,
-    const std::vector<int32>& attribs,
-    uint32 parent_texture_id,
-    int32 route_id,
-    int32 renderer_id,
-    int32 render_view_id)
-    : channel_(channel),
-      handle_(handle),
-      parent_(
-          parent ? parent->AsWeakPtr() : base::WeakPtr<GpuCommandBufferStub>()),
-      initial_size_(size),
-      allowed_extensions_(allowed_extensions),
-      requested_attribs_(attribs),
-      parent_texture_id_(parent_texture_id),
-      route_id_(route_id),
-#if defined(OS_WIN)
-      compositor_window_(NULL),
-#endif  // defined(OS_WIN)
-      renderer_id_(renderer_id),
-      render_view_id_(render_view_id) {
-}
-
-#if defined(OS_WIN)
-static LRESULT CALLBACK CompositorWindowProc(
-    HWND hwnd,
-    UINT message,
-    WPARAM wparam,
-    LPARAM lparam) {
-  switch (message) {
-    case WM_ERASEBKGND:
-      return 0;
-    case WM_DESTROY:
-      RemoveProp(hwnd, kCompositorWindowOwner);
-      return 0;
-    case WM_PAINT: {
-      PAINTSTRUCT paint;
-      HDC dc = BeginPaint(hwnd, &paint);
-      if (dc) {
-        HANDLE h = GetProp(hwnd, kCompositorWindowOwner);
-        if (h) {
-          GpuCommandBufferStub* stub =
-              reinterpret_cast<GpuCommandBufferStub*>(h);
-          stub->OnCompositorWindowPainted();
-        }
-        EndPaint(hwnd, &paint);
-      }
-      break;
-    }
-    default:
-      return DefWindowProc(hwnd, message, wparam, lparam);
-  }
-  return 0;
-}
-
-bool GpuCommandBufferStub::CreateCompositorWindow() {
-  DCHECK(handle_ != gfx::kNullPluginWindow);
-  HWND host_window = static_cast<HWND>(handle_);
-
-  // Create the compositor window itself.
-  DCHECK(host_window);
-  static ATOM window_class = 0;
-  if (!window_class) {
-    WNDCLASSEX wcex;
-    wcex.cbSize         = sizeof(wcex);
-    wcex.style          = 0;
-    wcex.lpfnWndProc    = CompositorWindowProc;
-    wcex.cbClsExtra     = 0;
-    wcex.cbWndExtra     = 0;
-    wcex.hInstance      = GetModuleHandle(NULL);
-    wcex.hIcon          = 0;
-    wcex.hCursor        = 0;
-    wcex.hbrBackground  = NULL;
-    wcex.lpszMenuName   = 0;
-    wcex.lpszClassName  = L"CompositorWindowClass";
-    wcex.hIconSm        = 0;
-    window_class = RegisterClassEx(&wcex);
-    DCHECK(window_class);
-  }
-
-  HWND compositor_window = CreateWindowEx(
-      WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR,
-      MAKEINTATOM(window_class),
-      0,
-      WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_DISABLED,
-      0, 0,
-      0, 0,
-      host_window,
-      0,
-      GetModuleHandle(NULL),
-      0);
-  if (!compositor_window) {
-    compositor_window_ = gfx::kNullPluginWindow;
-    return false;
-  }
-  SetProp(compositor_window, kCompositorWindowOwner,
-      reinterpret_cast<HANDLE>(this));
-
-  RECT parent_rect;
-  GetClientRect(host_window, &parent_rect);
-
-  UINT flags = SWP_NOSENDCHANGING | SWP_NOCOPYBITS | SWP_NOZORDER |
-      SWP_NOACTIVATE | SWP_DEFERERASE | SWP_SHOWWINDOW;
-  SetWindowPos(compositor_window,
-      NULL,
-      0, 0,
-      parent_rect.right - parent_rect.left,
-      parent_rect.bottom - parent_rect.top,
-      flags);
-  compositor_window_ = static_cast<gfx::PluginWindowHandle>(compositor_window);
-  return true;
-}
-
-void GpuCommandBufferStub::OnCompositorWindowPainted() {
-  GpuThread* gpu_thread = channel_->gpu_thread();
-  gpu_thread->Send(new GpuHostMsg_ScheduleComposite(
-      renderer_id_, render_view_id_));
-}
-#endif  // defined(OS_WIN)
-
-
-GpuCommandBufferStub::~GpuCommandBufferStub() {
-  if (processor_.get()) {
-    processor_->Destroy();
-  }
-#if defined(OS_WIN)
-  if (compositor_window_) {
-    DestroyWindow(static_cast<HWND>(compositor_window_));
-    compositor_window_ = NULL;
-  }
-#endif  // defined(OS_WIN)
-
-  GpuThread* gpu_thread = channel_->gpu_thread();
-  gpu_thread->Send(new GpuHostMsg_DestroyCommandBuffer(
-      handle_, renderer_id_, render_view_id_));
-}
-
-bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Initialize, OnInitialize);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetState, OnGetState);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncGetState, OnAsyncGetState);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Flush, OnFlush);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateTransferBuffer,
-                        OnCreateTransferBuffer);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
-                        OnRegisterTransferBuffer);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
-                        OnDestroyTransferBuffer);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetTransferBuffer,
-                        OnGetTransferBuffer);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_ResizeOffscreenFrameBuffer,
-                        OnResizeOffscreenFrameBuffer);
-#if defined(OS_MACOSX)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetWindowSize, OnSetWindowSize);
-#endif  // defined(OS_MACOSX)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  DCHECK(handled);
-  return handled;
-}
-
-bool GpuCommandBufferStub::Send(IPC::Message* message) {
-  return channel_->Send(message);
-}
-
-void GpuCommandBufferStub::OnInitialize(
-    base::SharedMemoryHandle ring_buffer,
-    int32 size,
-    bool* result) {
-  DCHECK(!command_buffer_.get());
-
-  *result = false;
-
-  command_buffer_.reset(new gpu::CommandBufferService);
-
-  // Create the child window, if needed
-#if defined(OS_WIN)
-  gfx::PluginWindowHandle output_window_handle;
-  if (handle_) {
-    if (!CreateCompositorWindow()) {
-      return;
-    }
-    output_window_handle = compositor_window_;
-  } else {
-    output_window_handle = handle_;
-  }
-#else
-  gfx::PluginWindowHandle output_window_handle = handle_;
-#endif  // defined(OS_WIN)
-
-#if defined(OS_WIN)
-  // Windows dups the shared memory handle it receives into the current process
-  // and closes it when this variable goes out of scope.
-  base::SharedMemory shared_memory(ring_buffer,
-                                   false,
-                                   channel_->renderer_process());
-#else
-  // POSIX receives a dup of the shared memory handle and closes the dup when
-  // this variable goes out of scope.
-  base::SharedMemory shared_memory(ring_buffer, false);
-#endif
-
-  // Initialize the CommandBufferService and GPUProcessor.
-  if (command_buffer_->Initialize(&shared_memory, size)) {
-    gpu::GPUProcessor* parent_processor =
-        parent_ ? parent_->processor_.get() : NULL;
-    processor_.reset(new gpu::GPUProcessor(command_buffer_.get(), NULL));
-    if (processor_->Initialize(
-        output_window_handle,
-        initial_size_,
-        allowed_extensions_.c_str(),
-        requested_attribs_,
-        parent_processor,
-        parent_texture_id_)) {
-      command_buffer_->SetPutOffsetChangeCallback(
-          NewCallback(processor_.get(),
-                      &gpu::GPUProcessor::ProcessCommands));
-      processor_->SetSwapBuffersCallback(
-          NewCallback(this, &GpuCommandBufferStub::OnSwapBuffers));
-
-#if defined(OS_MACOSX)
-      if (handle_) {
-        // This context conceptually puts its output directly on the
-        // screen, rendered by the accelerated plugin layer in
-        // RenderWidgetHostViewMac. Set up a pathway to notify the
-        // browser process when its contents change.
-        processor_->SetSwapBuffersCallback(
-            NewCallback(this,
-                        &GpuCommandBufferStub::SwapBuffersCallback));
-      }
-#endif  // defined(OS_MACOSX)
-
-      // Set up a pathway for resizing the output window or framebuffer at the
-      // right time relative to other GL commands.
-      processor_->SetResizeCallback(
-          NewCallback(this, &GpuCommandBufferStub::ResizeCallback));
-
-      *result = true;
-    } else {
-      processor_.reset();
-      command_buffer_.reset();
-    }
-  }
-}
-
-void GpuCommandBufferStub::OnGetState(gpu::CommandBuffer::State* state) {
-  *state = command_buffer_->GetState();
-}
-
-void GpuCommandBufferStub::OnAsyncGetState() {
-  gpu::CommandBuffer::State state = command_buffer_->GetState();
-  Send(new GpuCommandBufferMsg_UpdateState(route_id_, state));
-}
-
-void GpuCommandBufferStub::OnFlush(int32 put_offset,
-                                   gpu::CommandBuffer::State* state) {
-#if defined(OS_MACOSX)
-  // See comment in |DidDestroySurface()| in gpu_processor_mac.cc.
-  if (channel_->IsRenderViewGone(render_view_id_))
-    processor_->DidDestroySurface();
-#endif
-  *state = command_buffer_->FlushSync(put_offset);
-}
-
-void GpuCommandBufferStub::OnAsyncFlush(int32 put_offset) {
-  gpu::CommandBuffer::State state = command_buffer_->FlushSync(put_offset);
-  Send(new GpuCommandBufferMsg_UpdateState(route_id_, state));
-}
-
-void GpuCommandBufferStub::OnCreateTransferBuffer(int32 size, int32* id) {
-  *id = command_buffer_->CreateTransferBuffer(size);
-}
-
-void GpuCommandBufferStub::OnRegisterTransferBuffer(
-    base::SharedMemoryHandle transfer_buffer,
-    size_t size,
-    int32* id) {
-#if defined(OS_WIN)
-  // Windows dups the shared memory handle it receives into the current process
-  // and closes it when this variable goes out of scope.
-  base::SharedMemory shared_memory(transfer_buffer,
-                                   false,
-                                   channel_->renderer_process());
-#else
-  // POSIX receives a dup of the shared memory handle and closes the dup when
-  // this variable goes out of scope.
-  base::SharedMemory shared_memory(transfer_buffer, false);
-#endif
-
-  *id = command_buffer_->RegisterTransferBuffer(&shared_memory, size);
-}
-
-void GpuCommandBufferStub::OnDestroyTransferBuffer(int32 id) {
-  command_buffer_->DestroyTransferBuffer(id);
-}
-
-void GpuCommandBufferStub::OnGetTransferBuffer(
-    int32 id,
-    base::SharedMemoryHandle* transfer_buffer,
-    uint32* size) {
-  *transfer_buffer = base::SharedMemoryHandle();
-  *size = 0;
-
-  // Fail if the renderer process has not provided its process handle.
-  if (!channel_->renderer_process())
-    return;
-
-  Buffer buffer = command_buffer_->GetTransferBuffer(id);
-  if (buffer.shared_memory) {
-    // Assume service is responsible for duplicating the handle to the calling
-    // process.
-    buffer.shared_memory->ShareToProcess(channel_->renderer_process(),
-                                         transfer_buffer);
-    *size = buffer.size;
-  }
-}
-
-void GpuCommandBufferStub::OnResizeOffscreenFrameBuffer(const gfx::Size& size) {
-  processor_->ResizeOffscreenFrameBuffer(size);
-}
-
-void GpuCommandBufferStub::OnSwapBuffers() {
-  Send(new GpuCommandBufferMsg_SwapBuffers(route_id_));
-}
-
-#if defined(OS_MACOSX)
-void GpuCommandBufferStub::OnSetWindowSize(const gfx::Size& size) {
-  GpuThread* gpu_thread = channel_->gpu_thread();
-  // Try using the IOSurface version first.
-  uint64 new_backing_store = processor_->SetWindowSizeForIOSurface(size);
-  if (new_backing_store) {
-    GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params params;
-    params.renderer_id = renderer_id_;
-    params.render_view_id = render_view_id_;
-    params.window = handle_;
-    params.width = size.width();
-    params.height = size.height();
-    params.identifier = new_backing_store;
-    gpu_thread->Send(new GpuHostMsg_AcceleratedSurfaceSetIOSurface(params));
-  } else {
-    // TODO(kbr): figure out what to do here. It wouldn't be difficult
-    // to support the compositor on 10.5, but the performance would be
-    // questionable.
-    NOTREACHED();
-  }
-}
-
-void GpuCommandBufferStub::SwapBuffersCallback() {
-  OnSwapBuffers();
-  GpuThread* gpu_thread = channel_->gpu_thread();
-  GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
-  params.renderer_id = renderer_id_;
-  params.render_view_id = render_view_id_;
-  params.window = handle_;
-  params.surface_id = processor_->GetSurfaceId();
-  params.route_id = route_id();
-  params.swap_buffers_count = processor_->swap_buffers_count();
-  gpu_thread->Send(new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
-}
-
-void GpuCommandBufferStub::AcceleratedSurfaceBuffersSwapped(
-    uint64 swap_buffers_count) {
-  processor_->set_acknowledged_swap_buffers_count(swap_buffers_count);
-  // Wake up the GpuProcessor to start doing work again.
-  processor_->ScheduleProcessCommands();
-}
-#endif  // defined(OS_MACOSX)
-
-void GpuCommandBufferStub::ResizeCallback(gfx::Size size) {
-  if (handle_ == gfx::kNullPluginWindow) {
-    processor_->decoder()->ResizeOffscreenFrameBuffer(size);
-    processor_->decoder()->UpdateOffscreenFrameBufferSize();
-  } else {
-#if defined(OS_LINUX) && !defined(TOUCH_UI)
-    GpuThread* gpu_thread = channel_->gpu_thread();
-    bool result = false;
-    gpu_thread->Send(
-        new GpuHostMsg_ResizeXID(handle_, size, &result));
-#elif defined(OS_WIN)
-    HWND hwnd = static_cast<HWND>(compositor_window_);
-    UINT swp_flags = SWP_NOSENDCHANGING | SWP_NOOWNERZORDER | SWP_NOCOPYBITS |
-      SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE;
-    SetWindowPos(hwnd, NULL, 0, 0, size.width(), size.height(), swp_flags);
-#endif  // defined(OS_LINUX)
-  }
-}
-
-#endif  // defined(ENABLE_GPU)
diff --git a/chrome/gpu/gpu_command_buffer_stub.h b/chrome/gpu/gpu_command_buffer_stub.h
deleted file mode 100644
index 7124e25..0000000
--- a/chrome/gpu/gpu_command_buffer_stub.h
+++ /dev/null
@@ -1,131 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_GPU_COMMAND_BUFFER_STUB_H_
-#define CHROME_GPU_GPU_COMMAND_BUFFER_STUB_H_
-#pragma once
-
-#if defined(ENABLE_GPU)
-
-#include <vector>
-#include <string>
-
-#include "base/process.h"
-#include "base/weak_ptr.h"
-#include "gpu/command_buffer/service/command_buffer_service.h"
-#include "gpu/command_buffer/service/gpu_processor.h"
-#include "ipc/ipc_channel.h"
-#include "ipc/ipc_message.h"
-#include "ui/gfx/native_widget_types.h"
-#include "ui/gfx/size.h"
-
-class GpuChannel;
-
-class GpuCommandBufferStub
-    : public IPC::Channel::Listener,
-      public IPC::Message::Sender,
-      public base::SupportsWeakPtr<GpuCommandBufferStub> {
- public:
-  GpuCommandBufferStub(GpuChannel* channel,
-                       gfx::PluginWindowHandle handle,
-                       GpuCommandBufferStub* parent,
-                       const gfx::Size& size,
-                       const std::string& allowed_extensions,
-                       const std::vector<int32>& attribs,
-                       uint32 parent_texture_id,
-                       int32 route_id,
-                       int32 renderer_id,
-                       int32 render_view_id);
-
-  virtual ~GpuCommandBufferStub();
-
-  // IPC::Channel::Listener implementation:
-  virtual bool OnMessageReceived(const IPC::Message& message);
-
-  // IPC::Message::Sender implementation:
-  virtual bool Send(IPC::Message* msg);
-
-  // Get the GLContext associated with this object.
-  gpu::GPUProcessor* processor() const { return processor_.get(); }
-
-  // Identifies the various GpuCommandBufferStubs in the GPU process belonging
-  // to the same renderer process.
-  int32 route_id() const { return route_id_; }
-
-  // Identifies the various render views in the renderer process.
-  int32 renderer_route_id() const { return renderer_id_; }
-
-#if defined(OS_WIN)
-  // Called only by the compositor window's window proc
-  void OnCompositorWindowPainted();
-#endif  // defined(OS_WIN)
-
-#if defined(OS_MACOSX)
-  // Called only by the GpuChannel.
-  void AcceleratedSurfaceBuffersSwapped(uint64 swap_buffers_count);
-#endif  // defined(OS_MACOSX)
-
- private:
-  // Message handlers:
-  void OnInitialize(base::SharedMemoryHandle ring_buffer,
-                    int32 size,
-                    bool* result);
-  void OnGetState(gpu::CommandBuffer::State* state);
-  void OnAsyncGetState();
-  void OnFlush(int32 put_offset, gpu::CommandBuffer::State* state);
-  void OnAsyncFlush(int32 put_offset);
-  void OnCreateTransferBuffer(int32 size, int32* id);
-  void OnRegisterTransferBuffer(base::SharedMemoryHandle transfer_buffer,
-                                size_t size,
-                                int32* id);
-  void OnDestroyTransferBuffer(int32 id);
-  void OnGetTransferBuffer(int32 id,
-                           base::SharedMemoryHandle* transfer_buffer,
-                           uint32* size);
-  void OnResizeOffscreenFrameBuffer(const gfx::Size& size);
-
-  void OnSwapBuffers();
-
-#if defined(OS_MACOSX)
-  void OnSetWindowSize(const gfx::Size& size);
-  void SwapBuffersCallback();
-#endif  // defined(OS_MACOSX)
-
-#if defined(OS_WIN)
-  bool CreateCompositorWindow();
-#endif  // defined(OS_WIN)
-
-  void ResizeCallback(gfx::Size size);
-
-  // The lifetime of objects of this class is managed by a GpuChannel. The
-  // GpuChannels destroy all the GpuCommandBufferStubs that they own when they
-  // are destroyed. So a raw pointer is safe.
-  GpuChannel* channel_;
-
-  gfx::PluginWindowHandle handle_;
-  base::WeakPtr<GpuCommandBufferStub> parent_;
-  gfx::Size initial_size_;
-  std::string allowed_extensions_;
-  std::vector<int32> requested_attribs_;
-  uint32 parent_texture_id_;
-  int32 route_id_;
-
-#if defined(OS_WIN)
-  HWND compositor_window_;
-#endif  // defined(OS_WIN)
-
-  // The following two fields are used on Mac OS X to identify the window
-  // for the rendering results on the browser side.
-  int32 renderer_id_;
-  int32 render_view_id_;
-
-  scoped_ptr<gpu::CommandBufferService> command_buffer_;
-  scoped_ptr<gpu::GPUProcessor> processor_;
-
-  DISALLOW_COPY_AND_ASSIGN(GpuCommandBufferStub);
-};
-
-#endif  // defined(ENABLE_GPU)
-
-#endif  // CHROME_GPU_GPU_COMMAND_BUFFER_STUB_H_
diff --git a/chrome/gpu/gpu_config.h b/chrome/gpu/gpu_config.h
deleted file mode 100644
index 884d2ff..0000000
--- a/chrome/gpu/gpu_config.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_GPU_CONFIG_H_
-#define CHROME_GPU_GPU_CONFIG_H_
-#pragma once
-
-// This file declares common preprocessor configuration for the GPU process.
-
-#include "build/build_config.h"
-
-#endif  // CHROME_GPU_GPU_CONFIG_H_
diff --git a/chrome/gpu/gpu_dx_diagnostics_win.cc b/chrome/gpu/gpu_dx_diagnostics_win.cc
deleted file mode 100644
index 8c1960d..0000000
--- a/chrome/gpu/gpu_dx_diagnostics_win.cc
+++ /dev/null
@@ -1,135 +0,0 @@
-// 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.
-//
-// Functions to enumerate the Dx Diagnostic Tool hierarchy and build up
-// a tree of nodes with name / value properties.
-
-#define INITGUID
-#include <dxdiag.h>
-#include <windows.h>
-
-#include "chrome/gpu/gpu_info_collector.h"
-
-#include "base/string_number_conversions.h"
-#include "base/utf_string_conversions.h"
-
-namespace {
-
-// Traverses the IDxDiagContainer tree and populates a tree of DxDiagNode
-// structures that contains property name / value pairs and subtrees of DirectX
-// diagnostic information.
-void RecurseDiagnosticTree(DxDiagNode* output,
-                           IDxDiagContainer* container,
-                           int depth) {
-  HRESULT hr;
-
-  VARIANT variant;
-  VariantInit(&variant);
-
-  DWORD prop_count;
-  hr = container->GetNumberOfProps(&prop_count);
-  if (SUCCEEDED(hr)) {
-    for (DWORD i = 0; i < prop_count; i++) {
-      WCHAR prop_name16[256];
-      hr = container->EnumPropNames(i, prop_name16, arraysize(prop_name16));
-      if (SUCCEEDED(hr)) {
-        std::string prop_name8 = WideToUTF8(prop_name16);
-
-        hr = container->GetProp(prop_name16, &variant);
-        if (SUCCEEDED(hr)) {
-          switch (variant.vt) {
-            case VT_UI4:
-              output->values[prop_name8] = base::UintToString(variant.ulVal);
-              break;
-            case VT_I4:
-              output->values[prop_name8] = base::IntToString(variant.lVal);
-              break;
-            case VT_BOOL:
-              output->values[prop_name8] = variant.boolVal ? "true" : "false";
-              break;
-            case VT_BSTR:
-              output->values[prop_name8] = WideToUTF8(variant.bstrVal);
-              break;
-            default:
-              break;
-          }
-
-          // Clear the variant (this is needed to free BSTR memory).
-          VariantClear(&variant);
-        }
-      }
-    }
-  }
-
-  if (depth > 0) {
-    DWORD child_count;
-    hr = container->GetNumberOfChildContainers(&child_count);
-    if (SUCCEEDED(hr)) {
-      for (DWORD i = 0; i < child_count; i++) {
-        WCHAR child_name16[256];
-        hr = container->EnumChildContainerNames(i,
-                                                child_name16,
-                                                arraysize(child_name16));
-        if (SUCCEEDED(hr)) {
-          std::string child_name8 = WideToUTF8(child_name16);
-          DxDiagNode* output_child =
-              &output->children[child_name8];
-
-          IDxDiagContainer* child_container = NULL;
-          hr = container->GetChildContainer(child_name16, &child_container);
-          if (SUCCEEDED(hr)) {
-            RecurseDiagnosticTree(output_child, child_container, depth - 1);
-
-            child_container->Release();
-          }
-        }
-      }
-    }
-  }
-}
-}  // namespace anonymous
-
-namespace gpu_info_collector {
-
-bool GetDxDiagnostics(DxDiagNode* output) {
-  HRESULT hr;
-  bool success = false;
-
-  IDxDiagProvider* provider = NULL;
-  hr = CoCreateInstance(CLSID_DxDiagProvider,
-                         NULL,
-                         CLSCTX_INPROC_SERVER,
-                         IID_IDxDiagProvider,
-                         reinterpret_cast<void**>(&provider));
-  if (SUCCEEDED(hr)) {
-    DXDIAG_INIT_PARAMS params = { sizeof(params) };
-    params.dwDxDiagHeaderVersion = DXDIAG_DX9_SDK_VERSION;
-    params.bAllowWHQLChecks = FALSE;
-    params.pReserved = NULL;
-
-    hr = provider->Initialize(&params);
-    if (SUCCEEDED(hr)) {
-      IDxDiagContainer* root = NULL;
-      hr = provider->GetRootContainer(&root);
-      if (SUCCEEDED(hr)) {
-        // Limit to the DisplayDevices subtree. The tree in its entirity is
-        // enormous and only this branch contains useful information.
-        IDxDiagContainer* display_devices = NULL;
-        hr = root->GetChildContainer(L"DxDiag_DisplayDevices",
-                                     &display_devices);
-        if (SUCCEEDED(hr)) {
-          RecurseDiagnosticTree(output, display_devices, 1);
-          success = true;
-          display_devices->Release();
-        }
-
-        root->Release();
-      }
-    }
-    provider->Release();
-  }
-
-  return success;
-}
-}  // namespace gpu_info_collector
diff --git a/chrome/gpu/gpu_idirect3d9_mock_win.cc b/chrome/gpu/gpu_idirect3d9_mock_win.cc
deleted file mode 100644
index aef4482..0000000
--- a/chrome/gpu/gpu_idirect3d9_mock_win.cc
+++ /dev/null
@@ -1,9 +0,0 @@
-// 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 "chrome/gpu/gpu_idirect3d9_mock_win.h"
-
-IDirect3D9Mock::IDirect3D9Mock() {}
-
-IDirect3D9Mock::~IDirect3D9Mock() {}
diff --git a/chrome/gpu/gpu_idirect3d9_mock_win.h b/chrome/gpu/gpu_idirect3d9_mock_win.h
deleted file mode 100644
index 30568c3..0000000
--- a/chrome/gpu/gpu_idirect3d9_mock_win.h
+++ /dev/null
@@ -1,77 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_GPU_IDIRECT3D9_MOCK_WIN_H__
-#define CHROME_GPU_GPU_IDIRECT3D9_MOCK_WIN_H__
-#pragma once
-
-#include <d3d9.h>
-#include <windows.h>
-
-#include "testing/gmock/include/gmock/gmock.h"
-
-class IDirect3D9Mock : public IDirect3D9 {
- public:
-  IDirect3D9Mock();
-  virtual ~IDirect3D9Mock();
-
-  MOCK_METHOD5_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, CheckDepthStencilMatch,
-      HRESULT(UINT Adapter, D3DDEVTYPE DeviceType,
-              D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat,
-              D3DFORMAT DepthStencilFormat));
-  MOCK_METHOD6_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, CheckDeviceFormat,
-      HRESULT(UINT Adapter, D3DDEVTYPE DeviceType,
-              D3DFORMAT AdapterFormat, DWORD Usage,
-              D3DRESOURCETYPE RType, D3DFORMAT CheckFormat));
-  MOCK_METHOD4_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, CheckDeviceFormatConversion,
-      HRESULT(UINT Adapter, D3DDEVTYPE DeviceType,
-              D3DFORMAT SourceFormat, D3DFORMAT TargetFormat));
-  MOCK_METHOD6_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, CheckDeviceMultiSampleType,
-      HRESULT(UINT Adapter, D3DDEVTYPE DeviceType,
-              D3DFORMAT SurfaceFormat, BOOL Windowed,
-              D3DMULTISAMPLE_TYPE MultiSampleType,
-              DWORD* pQualityLevels));
-  MOCK_METHOD5_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, CheckDeviceType,
-      HRESULT(UINT Adapter, D3DDEVTYPE DevType,
-              D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat,
-              BOOL bWindowed));
-  MOCK_METHOD6_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, CreateDevice,
-      HRESULT(UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow,
-              DWORD BehaviorFlags,
-              D3DPRESENT_PARAMETERS* pPresentationParameters,
-              IDirect3DDevice9** ppReturnedDeviceInterface));
-  MOCK_METHOD4_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, EnumAdapterModes,
-      HRESULT(UINT Adapter, D3DFORMAT Format, UINT Mode,
-              D3DDISPLAYMODE* pMode));
-  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, GetAdapterCount, UINT());
-  MOCK_METHOD2_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, GetAdapterDisplayMode,
-      HRESULT(UINT Adapter, D3DDISPLAYMODE* pMode));
-  MOCK_METHOD3_WITH_CALLTYPE(
-      STDMETHODCALLTYPE, GetAdapterIdentifier,
-      HRESULT(UINT Adapter, DWORD Flags,
-              D3DADAPTER_IDENTIFIER9* pIdentifier));
-  MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, GetAdapterModeCount,
-                             UINT(UINT Adapter, D3DFORMAT Format));
-  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, GetAdapterMonitor,
-                             HMONITOR(UINT Adapter));
-  MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE, GetDeviceCaps,
-                             HRESULT(UINT Adapter, D3DDEVTYPE DeviceType,
-                                     D3DCAPS9* pCaps));
-  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, RegisterSoftwareDevice,
-                             HRESULT(void* pInitializeFunction));
-  MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, QueryInterface,
-                             HRESULT(REFIID riid, void** ppvObj));
-  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, AddRef, ULONG());
-  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, Release, ULONG());
-};
-
-#endif  // CHROME_GPU_GPU_IDIRECT3D9_MOCK_WIN_H__
diff --git a/chrome/gpu/gpu_info_collector.cc b/chrome/gpu/gpu_info_collector.cc
deleted file mode 100644
index 92bcb89..0000000
--- a/chrome/gpu/gpu_info_collector.cc
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) 2006-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 "chrome/gpu/gpu_info_collector.h"
-
-#include <string>
-#include <vector>
-
-#include "app/gfx/gl/gl_bindings.h"
-#include "app/gfx/gl/gl_context.h"
-#include "base/logging.h"
-#include "base/string_number_conversions.h"
-#include "base/string_piece.h"
-#include "base/string_split.h"
-
-namespace {
-
-// This creates an offscreen GL context for gl queries.  Returned GLContext
-// should be deleted in FinalizeGLContext.
-gfx::GLContext* InitializeGLContext() {
-  if (!gfx::GLContext::InitializeOneOff()) {
-    LOG(ERROR) << "gfx::GLContext::InitializeOneOff() failed";
-    return NULL;
-  }
-  gfx::GLContext* context = gfx::GLContext::CreateOffscreenGLContext(NULL);
-  if (context == NULL) {
-    LOG(ERROR) << "gfx::GLContext::CreateOffscreenGLContext(NULL) failed";
-    return NULL;
-  }
-  if (!context->MakeCurrent()) {
-    LOG(ERROR) << "gfx::GLContext::MakeCurrent() failed";
-    context->Destroy();
-    delete context;
-    return NULL;
-  }
-  return context;
-}
-
-// This destroy and delete the GL context.
-void FinalizeGLContext(gfx::GLContext** context) {
-  DCHECK(context);
-  if (*context) {
-    (*context)->Destroy();
-    delete *context;
-    *context = NULL;
-  }
-}
-
-std::string GetGLString(unsigned int pname) {
-  const char* gl_string =
-      reinterpret_cast<const char*>(glGetString(pname));
-  if (gl_string)
-    return std::string(gl_string);
-  return "";
-}
-
-uint32 GetVersionNumberFromString(const std::string& version_string) {
-  int major = 0, minor = 0;
-  size_t begin = version_string.find_first_of("0123456789");
-  if (begin != std::string::npos) {
-    size_t end = version_string.find_first_not_of("01234567890.", begin);
-    std::string sub_string;
-    if (end != std::string::npos)
-      sub_string = version_string.substr(begin, end - begin);
-    else
-      sub_string = version_string.substr(begin);
-    std::vector<std::string> pieces;
-    base::SplitString(sub_string, '.', &pieces);
-    if (pieces.size() >= 2) {
-      base::StringToInt(pieces[0], &major);
-      base::StringToInt(pieces[1], &minor);
-    }
-  }
-  return ((major << 8) + minor);
-}
-
-}  // namespace anonymous
-
-namespace gpu_info_collector {
-
-bool CollectGraphicsInfoGL(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  gfx::GLContext* context = InitializeGLContext();
-  if (context == NULL)
-    return false;
-
-  gpu_info->gl_renderer = GetGLString(GL_RENDERER);
-  gpu_info->gl_vendor = GetGLString(GL_VENDOR);
-  gpu_info->gl_version_string =GetGLString(GL_VERSION);
-  gpu_info->gl_extensions =GetGLString(GL_EXTENSIONS);
-
-  bool validGLVersionInfo = CollectGLVersionInfo(gpu_info);
-  bool validVideoCardInfo = CollectVideoCardInfo(gpu_info);
-  bool validDriverInfo = CollectDriverInfoGL(gpu_info);
-
-  FinalizeGLContext(&context);
-
-  return (validGLVersionInfo && validVideoCardInfo && validDriverInfo);
-}
-
-bool CollectGLVersionInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  std::string gl_version_string = gpu_info->gl_version_string;
-  std::string glsl_version_string =
-      GetGLString(GL_SHADING_LANGUAGE_VERSION);
-
-  uint32 gl_version = GetVersionNumberFromString(gl_version_string);
-  gpu_info->gl_version = gl_version;
-
-  uint32 glsl_version = GetVersionNumberFromString(glsl_version_string);
-  gpu_info->pixel_shader_version = glsl_version;
-  gpu_info->vertex_shader_version = glsl_version;
-
-  return true;
-}
-
-}  // namespace gpu_info_collector
-
diff --git a/chrome/gpu/gpu_info_collector.h b/chrome/gpu/gpu_info_collector.h
deleted file mode 100644
index 91b77ac..0000000
--- a/chrome/gpu/gpu_info_collector.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2006-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.
-
-#ifndef CHROME_GPU_GPU_INFO_COLLECTOR_H__
-#define CHROME_GPU_GPU_INFO_COLLECTOR_H__
-#pragma once
-
-#include "base/basictypes.h"
-#include "build/build_config.h"
-#include "content/common/gpu_info.h"
-
-struct IDirect3D9;
-
-namespace gpu_info_collector {
-
-// Populate variables with necessary graphics card information.
-// Returns true on success.
-bool CollectGraphicsInfo(GPUInfo* gpu_info);
-
-// Similar to CollectGraphicsInfo, only this collects a subset of variables
-// without creating a GL/DirectX context (and without the danger of crashing).
-// The subset each platform collects may be different.
-bool CollectPreliminaryGraphicsInfo(GPUInfo* gpu_info);
-
-#if defined(OS_WIN)
-// Windows provides two ways of doing graphics so we need two ways of
-// collecting info based on what's on a user's machine.
-// The selection between the two methods is done in the cc file.
-
-// A D3D argument is passed in for testing purposes
-bool CollectGraphicsInfoD3D(IDirect3D9* d3d, GPUInfo* gpu_info);
-
-// Collects D3D driver version/date through registry lookup.
-// Note that this does not require a D3D context.
-// device_id here is the raw data in DISPLAY_DEVICE.
-bool CollectDriverInfoD3D(const std::wstring& device_id, GPUInfo* gpu_info);
-
-// Collect the DirectX Disagnostics information about the attached displays.
-bool GetDxDiagnostics(DxDiagNode* output);
-#endif
-
-// All platforms have a GL version for collecting information
-bool CollectGraphicsInfoGL(GPUInfo* gpu_info);
-
-// Collect GL and Shading language version information
-bool CollectGLVersionInfo(GPUInfo* gpu_info);
-
-// Platform specific method for collecting vendor and device ids
-bool CollectVideoCardInfo(GPUInfo* gpu_info);
-
-// Each platform stores the driver version on the GL_VERSION string differently
-bool CollectDriverInfoGL(GPUInfo* gpu_info);
-
-}  // namespace gpu_info_collector
-
-#endif  // CHROME_GPU_GPU_INFO_COLLECTOR_H__
diff --git a/chrome/gpu/gpu_info_collector_linux.cc b/chrome/gpu/gpu_info_collector_linux.cc
deleted file mode 100644
index e77d6ff..0000000
--- a/chrome/gpu/gpu_info_collector_linux.cc
+++ /dev/null
@@ -1,279 +0,0 @@
-// Copyright (c) 2006-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 "chrome/gpu/gpu_info_collector.h"
-
-#include <dlfcn.h>
-#include <vector>
-
-#include "app/gfx/gl/gl_bindings.h"
-#include "app/gfx/gl/gl_context.h"
-#include "app/gfx/gl/gl_implementation.h"
-#include "base/file_util.h"
-#include "base/logging.h"
-#include "base/scoped_ptr.h"
-#include "base/string_piece.h"
-#include "base/string_split.h"
-#include "base/string_util.h"
-
-namespace {
-
-// PciDevice and PciAccess are defined to access libpci functions.  Their
-// members match the corresponding structures defined by libpci in size up to
-// fields we may access.  For those members we don't use, their names are
-// defined as "fieldX", etc., or, left out if they are declared after the
-// members we care about in libpci.
-
-struct PciDevice {
-  PciDevice* next;
-
-  uint16 field0;
-  uint8 field1;
-  uint8 field2;
-  uint8 field3;
-  int field4;
-
-  uint16 vendor_id;
-  uint16 device_id;
-  uint16 device_class;
-};
-
-struct PciAccess {
-  unsigned int field0;
-  int field1;
-  int field2;
-  char* field3;
-  int field4;
-  int field5;
-  unsigned int field6;
-  int field7;
-
-  void (*function0)();
-  void (*function1)();
-  void (*function2)();
-
-  PciDevice* device_list;
-};
-
-// Define function types.
-typedef PciAccess* (*FT_pci_alloc)();
-typedef void (*FT_pci_init)(PciAccess*);
-typedef void (*FT_pci_cleanup)(PciAccess*);
-typedef void (*FT_pci_scan_bus)(PciAccess*);
-typedef void (*FT_pci_scan_bus)(PciAccess*);
-typedef int (*FT_pci_fill_info)(PciDevice*, int);
-typedef char* (*FT_pci_lookup_name)(PciAccess*, char*, int, int, ...);
-
-// This includes dynamically linked library handle and functions pointers from
-// libpci.
-struct PciInterface {
-  void* lib_handle;
-
-  FT_pci_alloc pci_alloc;
-  FT_pci_init pci_init;
-  FT_pci_cleanup pci_cleanup;
-  FT_pci_scan_bus pci_scan_bus;
-  FT_pci_fill_info pci_fill_info;
-  FT_pci_lookup_name pci_lookup_name;
-};
-
-// This checks if a system supports PCI bus.
-// We check the existence of /sys/bus/pci or /sys/bug/pci_express.
-bool IsPciSupported() {
-  const FilePath pci_path("/sys/bus/pci/");
-  const FilePath pcie_path("/sys/bus/pci_express/");
-  return (file_util::PathExists(pci_path) ||
-          file_util::PathExists(pcie_path));
-}
-
-// This dynamically opens libpci and get function pointers we need.  Return
-// NULL if library fails to open or any functions can not be located.
-// Returned interface (if not NULL) should be deleted in FinalizeLibPci.
-PciInterface* InitializeLibPci(const char* lib_name) {
-  void* handle = dlopen(lib_name, RTLD_LAZY);
-  if (handle == NULL) {
-    LOG(INFO) << "Failed to dlopen " << lib_name;
-    return NULL;
-  }
-  PciInterface* interface = new struct PciInterface;
-  interface->lib_handle = handle;
-  interface->pci_alloc = reinterpret_cast<FT_pci_alloc>(
-      dlsym(handle, "pci_alloc"));
-  interface->pci_init = reinterpret_cast<FT_pci_init>(
-      dlsym(handle, "pci_init"));
-  interface->pci_cleanup = reinterpret_cast<FT_pci_cleanup>(
-      dlsym(handle, "pci_cleanup"));
-  interface->pci_scan_bus = reinterpret_cast<FT_pci_scan_bus>(
-      dlsym(handle, "pci_scan_bus"));
-  interface->pci_fill_info = reinterpret_cast<FT_pci_fill_info>(
-      dlsym(handle, "pci_fill_info"));
-  interface->pci_lookup_name = reinterpret_cast<FT_pci_lookup_name>(
-      dlsym(handle, "pci_lookup_name"));
-  if (interface->pci_alloc == NULL ||
-      interface->pci_init == NULL ||
-      interface->pci_cleanup == NULL ||
-      interface->pci_scan_bus == NULL ||
-      interface->pci_fill_info == NULL ||
-      interface->pci_lookup_name == NULL) {
-    LOG(ERROR) << "Missing required function(s) from " << lib_name;
-    dlclose(handle);
-    delete interface;
-    return NULL;
-  }
-  return interface;
-}
-
-// This close the dynamically opened libpci and delete the interface.
-void FinalizeLibPci(PciInterface** interface) {
-  DCHECK(interface && *interface && (*interface)->lib_handle);
-  dlclose((*interface)->lib_handle);
-  delete (*interface);
-  *interface = NULL;
-}
-
-}  // namespace anonymous
-
-namespace gpu_info_collector {
-
-bool CollectGraphicsInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  // TODO(zmo): need to consider the case where we are running on top of
-  // desktop GL and GL_ARB_robustness extension is available.
-  gpu_info->can_lose_context =
-      (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2);
-  gpu_info->level = GPUInfo::kComplete;
-  return CollectGraphicsInfoGL(gpu_info);
-}
-
-bool CollectPreliminaryGraphicsInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  gpu_info->level = GPUInfo::kPartial;
-
-  bool rt = true;
-  if (!CollectVideoCardInfo(gpu_info))
-    rt = false;
-
-  // TODO(zmo): if vendor is ATI, consider passing /etc/ati/amdpcsdb.default
-  // for driver information.
-
-  return rt;
-}
-
-bool CollectVideoCardInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  if (IsPciSupported() == false) {
-    LOG(INFO) << "PCI bus scanning is not supported";
-    return false;
-  }
-
-  // TODO(zmo): be more flexible about library name.
-  PciInterface* interface = InitializeLibPci("libpci.so.3");
-  if (interface == NULL)
-    interface = InitializeLibPci("libpci.so");
-  if (interface == NULL) {
-    LOG(ERROR) << "Failed to locate libpci";
-    return false;
-  }
-
-  PciAccess* access = (interface->pci_alloc)();
-  DCHECK(access != NULL);
-  (interface->pci_init)(access);
-  (interface->pci_scan_bus)(access);
-  std::vector<PciDevice*> gpu_list;
-  PciDevice* gpu_active = NULL;
-  for (PciDevice* device = access->device_list;
-       device != NULL; device = device->next) {
-    (interface->pci_fill_info)(device, 33);  // Fill the IDs and class fields.
-    // TODO(zmo): there might be other classes that qualify as display devices.
-    if (device->device_class == 0x0300) {  // Device class is DISPLAY_VGA.
-      gpu_list.push_back(device);
-    }
-  }
-  if (gpu_list.size() == 1) {
-    gpu_active = gpu_list[0];
-  } else {
-    // If more than one graphics card are identified, find the one that matches
-    // gl VENDOR and RENDERER info.
-    std::string gl_vendor_string = gpu_info->gl_vendor;
-    std::string gl_renderer_string = gpu_info->gl_renderer;
-    const int buffer_size = 255;
-    scoped_array<char> buffer(new char[buffer_size]);
-    std::vector<PciDevice*> candidates;
-    for (size_t i = 0; i < gpu_list.size(); ++i) {
-      PciDevice* gpu = gpu_list[i];
-      // The current implementation of pci_lookup_name returns the same pointer
-      // as the passed in upon success, and a different one (NULL or a pointer
-      // to an error message) upon failure.
-      if ((interface->pci_lookup_name)(access,
-                                       buffer.get(),
-                                       buffer_size,
-                                       1,
-                                       gpu->vendor_id) != buffer.get())
-        continue;
-      std::string vendor_string = buffer.get();
-      const bool kCaseSensitive = false;
-      if (!StartsWithASCII(gl_vendor_string, vendor_string, kCaseSensitive))
-        continue;
-      if ((interface->pci_lookup_name)(access,
-                                       buffer.get(),
-                                       buffer_size,
-                                       2,
-                                       gpu->vendor_id,
-                                       gpu->device_id) != buffer.get())
-        continue;
-      std::string device_string = buffer.get();
-      size_t begin = device_string.find_first_of('[');
-      size_t end = device_string.find_last_of(']');
-      if (begin != std::string::npos && end != std::string::npos &&
-          begin < end) {
-        device_string = device_string.substr(begin + 1, end - begin - 1);
-      }
-      if (StartsWithASCII(gl_renderer_string, device_string, kCaseSensitive)) {
-        gpu_active = gpu;
-        break;
-      }
-      // If a device's vendor matches gl VENDOR string, we want to consider the
-      // possibility that libpci may not return the exact same name as gl
-      // RENDERER string.
-      candidates.push_back(gpu);
-    }
-    if (gpu_active == NULL && candidates.size() == 1)
-      gpu_active = candidates[0];
-  }
-  if (gpu_active != NULL) {
-    gpu_info->vendor_id =  gpu_active->vendor_id;
-    gpu_info->device_id = gpu_active->device_id;
-  }
-  (interface->pci_cleanup)(access);
-  FinalizeLibPci(&interface);
-  return (gpu_active != NULL);
-}
-
-bool CollectDriverInfoGL(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  std::string gl_version_string = gpu_info->gl_version_string;
-  std::vector<std::string> pieces;
-  base::SplitStringAlongWhitespace(gl_version_string, &pieces);
-  // In linux, the gl version string might be in the format of
-  //   GLVersion DriverVendor DriverVersion
-  if (pieces.size() < 3)
-    return false;
-
-  std::string driver_version = pieces[2];
-  size_t pos = driver_version.find_first_not_of("0123456789.");
-  if (pos == 0)
-    return false;
-  if (pos != std::string::npos)
-    driver_version = driver_version.substr(0, pos);
-
-  gpu_info->driver_vendor = pieces[1];
-  gpu_info->driver_version = driver_version;
-  return true;
-}
-
-}  // namespace gpu_info_collector
diff --git a/chrome/gpu/gpu_info_collector_mac.mm b/chrome/gpu/gpu_info_collector_mac.mm
deleted file mode 100644
index 68327fe..0000000
--- a/chrome/gpu/gpu_info_collector_mac.mm
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright (c) 2006-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 "chrome/gpu/gpu_info_collector.h"
-#include "base/logging.h"
-#include "base/scoped_ptr.h"
-#include "base/string_piece.h"
-#include "base/sys_string_conversions.h"
-#include "app/gfx/gl/gl_bindings.h"
-#include "app/gfx/gl/gl_context.h"
-#include "app/gfx/gl/gl_implementation.h"
-#include "app/gfx/gl/gl_interface.h"
-
-#import <Cocoa/Cocoa.h>
-#import <Foundation/Foundation.h>
-#import <IOKit/IOKitLib.h>
-
-namespace {
-
-CFTypeRef SearchPortForProperty(io_registry_entry_t dspPort,
-                                CFStringRef propertyName) {
-  return IORegistryEntrySearchCFProperty(dspPort,
-                                         kIOServicePlane,
-                                         propertyName,
-                                         kCFAllocatorDefault,
-                                         kIORegistryIterateRecursively |
-                                         kIORegistryIterateParents);
-}
-
-UInt32 IntValueOfCFData(CFDataRef data_ref) {
-  DCHECK(data_ref);
-
-  UInt32 value = 0;
-  const UInt32* value_pointer =
-      reinterpret_cast<const UInt32*>(CFDataGetBytePtr(data_ref));
-  if (value_pointer != NULL)
-    value = *value_pointer;
-  return value;
-}
-
-}  // namespace anonymous
-
-namespace gpu_info_collector {
-
-bool CollectGraphicsInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  gpu_info->can_lose_context =
-      (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2);
-  gpu_info-> level = GPUInfo::kComplete;
-  return CollectGraphicsInfoGL(gpu_info);
-}
-
-bool CollectPreliminaryGraphicsInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  gpu_info->level = GPUInfo::kPartial;
-
-  bool rt = true;
-  if (!CollectVideoCardInfo(gpu_info))
-    rt = false;
-
-  return rt;
-}
-
-bool CollectVideoCardInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  UInt32 vendor_id = 0, device_id = 0;
-  io_registry_entry_t dsp_port = CGDisplayIOServicePort(kCGDirectMainDisplay);
-  CFTypeRef vendor_id_ref = SearchPortForProperty(dsp_port, CFSTR("vendor-id"));
-  if (vendor_id_ref) {
-    vendor_id = IntValueOfCFData((CFDataRef)vendor_id_ref);
-    CFRelease(vendor_id_ref);
-  }
-  CFTypeRef device_id_ref = SearchPortForProperty(dsp_port, CFSTR("device-id"));
-  if (device_id_ref) {
-    device_id = IntValueOfCFData((CFDataRef)device_id_ref);
-    CFRelease(device_id_ref);
-  }
-
-  gpu_info->vendor_id = vendor_id;
-  gpu_info->device_id = device_id;
-  return true;
-}
-
-bool CollectDriverInfoGL(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  // Extract the OpenGL driver version string from the GL_VERSION string.
-  // Mac OpenGL drivers have the driver version
-  // at the end of the gl version string preceded by a dash.
-  // Use some jiggery-pokery to turn that utf8 string into a std::wstring.
-  std::string gl_version_string = gpu_info->gl_version_string;
-  size_t pos = gl_version_string.find_last_of('-');
-  if (pos == std::string::npos)
-    return false;
-  gpu_info->driver_version = gl_version_string.substr(pos + 1);
-  return true;
-}
-
-}  // namespace gpu_info_collector
diff --git a/chrome/gpu/gpu_info_collector_unittest.cc b/chrome/gpu/gpu_info_collector_unittest.cc
deleted file mode 100644
index 87e6376..0000000
--- a/chrome/gpu/gpu_info_collector_unittest.cc
+++ /dev/null
@@ -1,177 +0,0 @@
-// 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 "app/gfx/gl/gl_implementation.h"
-#include "base/scoped_ptr.h"
-#include "chrome/gpu/gpu_info_collector.h"
-#include "content/common/gpu_info.h"
-#include "gpu/command_buffer/common/gl_mock.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::gfx::MockGLInterface;
-using ::testing::Return;
-
-class GPUInfoCollectorTest : public testing::Test {
- public:
-  GPUInfoCollectorTest() {}
-  virtual ~GPUInfoCollectorTest() { }
-
-  void SetUp() {
-    gfx::InitializeGLBindings(gfx::kGLImplementationMockGL);
-    gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
-    ::gfx::GLInterface::SetGLInterface(gl_.get());
-#if defined(OS_WIN)
-    const uint32 vendor_id = 0x10de;
-    const uint32 device_id = 0x0658;
-    const char* driver_vendor = "";  // not implemented
-    const char* driver_version = "";
-    const uint32 shader_version = 0x00000128;
-    const uint32 gl_version = 0x00000301;
-    const char* gl_renderer = "Quadro FX 380/PCI/SSE2";
-    const char* gl_vendor = "NVIDIA Corporation";
-    const char* gl_version_string = "3.1.0";
-    const char* gl_shading_language_version = "1.40 NVIDIA via Cg compiler";
-    const char* gl_extensions =
-        "GL_OES_packed_depth_stencil GL_EXT_texture_format_BGRA8888 "
-        "GL_EXT_read_format_bgra";
-#elif defined(OS_MACOSX)
-    const uint32 vendor_id = 0x10de;
-    const uint32 device_id = 0x0640;
-    const char* driver_vendor = "";  // not implemented
-    const char* driver_version = "1.6.18";
-    const uint32 shader_version = 0x00000114;
-    const uint32 gl_version = 0x00000201;
-    const char* gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
-    const char* gl_vendor = "NVIDIA Corporation";
-    const char* gl_version_string = "2.1 NVIDIA-1.6.18";
-    const char* gl_shading_language_version = "1.20 ";
-    const char* gl_extensions =
-        "GL_OES_packed_depth_stencil GL_EXT_texture_format_BGRA8888 "
-        "GL_EXT_read_format_bgra";
-#else  // defined (OS_LINUX)
-    const uint32 vendor_id = 0x10de;
-    const uint32 device_id = 0x0658;
-    const char* driver_vendor = "NVIDIA";
-    const char* driver_version = "195.36.24";
-    const uint32 shader_version = 0x00000132;
-    const uint32 gl_version = 0x00000302;
-    const char* gl_renderer = "Quadro FX 380/PCI/SSE2";
-    const char* gl_vendor = "NVIDIA Corporation";
-    const char* gl_version_string = "3.2.0 NVIDIA 195.36.24";
-    const char* gl_shading_language_version = "1.50 NVIDIA via Cg compiler";
-    const char* gl_extensions =
-        "GL_OES_packed_depth_stencil GL_EXT_texture_format_BGRA8888 "
-        "GL_EXT_read_format_bgra";
-#endif
-    test_values_.vendor_id = vendor_id;
-    test_values_.device_id = device_id;
-    test_values_.driver_vendor = driver_vendor;
-    test_values_.driver_version =driver_version;
-    test_values_.driver_date = "";
-    test_values_.pixel_shader_version = shader_version;
-    test_values_.vertex_shader_version = shader_version;
-    test_values_.gl_version = gl_version;
-    test_values_.gl_renderer = gl_renderer;
-    test_values_.gl_vendor = gl_vendor;
-    test_values_.gl_version_string = gl_version_string;
-    test_values_.gl_extensions = gl_extensions;
-    test_values_.can_lose_context = false;
-
-    EXPECT_CALL(*gl_, GetString(GL_EXTENSIONS))
-        .WillRepeatedly(Return(reinterpret_cast<const GLubyte*>(
-            gl_extensions)));
-    EXPECT_CALL(*gl_, GetString(GL_SHADING_LANGUAGE_VERSION))
-        .WillRepeatedly(Return(reinterpret_cast<const GLubyte*>(
-            gl_shading_language_version)));
-    EXPECT_CALL(*gl_, GetString(GL_VERSION))
-        .WillRepeatedly(Return(reinterpret_cast<const GLubyte*>(
-            gl_version_string)));
-    EXPECT_CALL(*gl_, GetString(GL_VENDOR))
-        .WillRepeatedly(Return(reinterpret_cast<const GLubyte*>(
-            gl_vendor)));
-    EXPECT_CALL(*gl_, GetString(GL_RENDERER))
-        .WillRepeatedly(Return(reinterpret_cast<const GLubyte*>(
-            gl_renderer)));
-  }
-
-  void TearDown() {
-    ::gfx::GLInterface::SetGLInterface(NULL);
-    gl_.reset();
-  }
-
- public:
-  // Use StrictMock to make 100% sure we know how GL will be called.
-  scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
-  GPUInfo test_values_;
-};
-
-// TODO(rlp): Test the vendor and device id collection if deemed necessary as
-//            it involves several complicated mocks for each platform.
-
-TEST_F(GPUInfoCollectorTest, DriverVendorGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  std::string driver_vendor = gpu_info.driver_vendor;
-  EXPECT_EQ(test_values_.driver_vendor, driver_vendor);
-}
-
-// Skip Windows because the driver version is obtained from bot registry.
-#if !defined(OS_WIN)
-TEST_F(GPUInfoCollectorTest, DriverVersionGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  std::string driver_version = gpu_info.driver_version;
-  EXPECT_EQ(test_values_.driver_version, driver_version);
-}
-#endif
-
-TEST_F(GPUInfoCollectorTest, PixelShaderVersionGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  uint32 ps_version = gpu_info.pixel_shader_version;
-  EXPECT_EQ(test_values_.pixel_shader_version, ps_version);
-}
-
-TEST_F(GPUInfoCollectorTest, VertexShaderVersionGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  uint32 vs_version = gpu_info.vertex_shader_version;
-  EXPECT_EQ(test_values_.vertex_shader_version, vs_version);
-}
-
-TEST_F(GPUInfoCollectorTest, GLVersionGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  uint32 gl_version = gpu_info.gl_version;
-  EXPECT_EQ(test_values_.gl_version, gl_version);
-}
-
-TEST_F(GPUInfoCollectorTest, GLVersionStringGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  std::string gl_version_string = gpu_info.gl_version_string;
-  EXPECT_EQ(test_values_.gl_version_string, gl_version_string);
-}
-
-TEST_F(GPUInfoCollectorTest, GLRendererGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  std::string gl_renderer = gpu_info.gl_renderer;
-  EXPECT_EQ(test_values_.gl_renderer, gl_renderer);
-}
-
-TEST_F(GPUInfoCollectorTest, GLVendorGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  std::string gl_vendor = gpu_info.gl_vendor;
-  EXPECT_EQ(test_values_.gl_vendor, gl_vendor);
-}
-
-TEST_F(GPUInfoCollectorTest, GLExtensionsGL) {
-  GPUInfo gpu_info;
-  gpu_info_collector::CollectGraphicsInfoGL(&gpu_info);
-  std::string gl_extensions = gpu_info.gl_extensions;
-  EXPECT_EQ(test_values_.gl_extensions, gl_extensions);
-}
diff --git a/chrome/gpu/gpu_info_collector_win.cc b/chrome/gpu/gpu_info_collector_win.cc
deleted file mode 100644
index 2617fb0..0000000
--- a/chrome/gpu/gpu_info_collector_win.cc
+++ /dev/null
@@ -1,264 +0,0 @@
-// 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 "chrome/gpu/gpu_info_collector.h"
-
-#include <d3d9.h>
-#include <setupapi.h>
-#include <windows.h>
-
-#include "app/gfx/gl/gl_context_egl.h"
-#include "app/gfx/gl/gl_implementation.h"
-#include "base/file_path.h"
-#include "base/logging.h"
-#include "base/scoped_native_library.h"
-#include "base/string_number_conversions.h"
-#include "base/string_util.h"
-
-// ANGLE seems to require that main.h be included before any other ANGLE header.
-#include "libEGL/main.h"
-#include "libEGL/Display.h"
-
-// Setup API functions
-typedef HDEVINFO (WINAPI*SetupDiGetClassDevsWFunc)(
-    CONST GUID *ClassGuid,
-    PCWSTR Enumerator,
-    HWND hwndParent,
-    DWORD Flags
-);
-typedef BOOL (WINAPI*SetupDiEnumDeviceInfoFunc)(
-    HDEVINFO DeviceInfoSet,
-    DWORD MemberIndex,
-    PSP_DEVINFO_DATA DeviceInfoData
-);
-typedef BOOL (WINAPI*SetupDiGetDeviceRegistryPropertyWFunc)(
-    HDEVINFO DeviceInfoSet,
-    PSP_DEVINFO_DATA DeviceInfoData,
-    DWORD Property,
-    PDWORD PropertyRegDataType,
-    PBYTE PropertyBuffer,
-    DWORD PropertyBufferSize,
-    PDWORD RequiredSize
-);
-typedef BOOL (WINAPI*SetupDiDestroyDeviceInfoListFunc)(
-    HDEVINFO DeviceInfoSet
-);
-
-namespace gpu_info_collector {
-
-bool CollectGraphicsInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
-    gpu_info->level = GPUInfo::kComplete;
-    return CollectGraphicsInfoGL(gpu_info);
-  }
-
-  // Set to partial now in case this function returns false below.
-  gpu_info->level = GPUInfo::kPartial;
-
-  // TODO(zmo): the following code only works if running on top of ANGLE.
-  // Need to handle the case when running on top of real EGL/GLES2 drivers.
-
-  egl::Display* display = static_cast<egl::Display*>(
-      gfx::BaseEGLContext::GetDisplay());
-  if (!display) {
-    LOG(ERROR) << "gfx::BaseEGLContext::GetDisplay() failed";
-    return false;
-  }
-
-  IDirect3DDevice9* device = display->getDevice();
-  if (!device) {
-    LOG(ERROR) << "display->getDevice() failed";
-    return false;
-  }
-
-  IDirect3D9* d3d = NULL;
-  if (FAILED(device->GetDirect3D(&d3d))) {
-    LOG(ERROR) << "device->GetDirect3D(&d3d) failed";
-    return false;
-  }
-
-  if (!CollectGraphicsInfoD3D(d3d, gpu_info))
-    return false;
-
-  // DirectX diagnostics are collected asynchronously because it takes a
-  // couple of seconds. Do not mark gpu_info as complete until that is done.
-  return true;
-}
-
-bool CollectPreliminaryGraphicsInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  gpu_info->level = GPUInfo::kPreliminary;
-
-  bool rt = true;
-  if (!CollectVideoCardInfo(gpu_info))
-    rt = false;
-
-  return rt;
-}
-
-bool CollectGraphicsInfoD3D(IDirect3D9* d3d, GPUInfo* gpu_info) {
-  DCHECK(d3d);
-  DCHECK(gpu_info);
-
-  bool succeed = CollectVideoCardInfo(gpu_info);
-
-  // Get version information
-  D3DCAPS9 d3d_caps;
-  if (d3d->GetDeviceCaps(D3DADAPTER_DEFAULT,
-                         D3DDEVTYPE_HAL,
-                         &d3d_caps) == D3D_OK) {
-    gpu_info->pixel_shader_version = d3d_caps.PixelShaderVersion;
-    gpu_info->vertex_shader_version = d3d_caps.VertexShaderVersion;
-  } else {
-    LOG(ERROR) << "d3d->GetDeviceCaps() failed";
-    succeed = false;
-  }
-
-  // Get can_lose_context
-  bool can_lose_context = false;
-  IDirect3D9Ex* d3dex = NULL;
-  if (SUCCEEDED(d3d->QueryInterface(__uuidof(IDirect3D9Ex),
-                                    reinterpret_cast<void**>(&d3dex)))) {
-    d3dex->Release();
-  } else {
-    can_lose_context = true;
-  }
-  gpu_info->can_lose_context = can_lose_context;
-
-  d3d->Release();
-  return true;
-}
-
-bool CollectVideoCardInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  // Taken from http://developer.nvidia.com/object/device_ids.html
-  DISPLAY_DEVICE dd;
-  dd.cb = sizeof(DISPLAY_DEVICE);
-  int i = 0;
-  std::wstring id;
-  for (int i = 0; EnumDisplayDevices(NULL, i, &dd, 0); ++i) {
-    if (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
-      id = dd.DeviceID;
-      break;
-    }
-  }
-
-  if (id.length() > 20) {
-    int vendor_id = 0, device_id = 0;
-    std::wstring vendor_id_string = id.substr(8, 4);
-    std::wstring device_id_string = id.substr(17, 4);
-    base::HexStringToInt(WideToASCII(vendor_id_string), &vendor_id);
-    base::HexStringToInt(WideToASCII(device_id_string), &device_id);
-    gpu_info->vendor_id = vendor_id;
-    gpu_info->device_id = device_id;
-    // TODO(zmo): we only need to call CollectDriverInfoD3D() if we use ANGLE.
-    return CollectDriverInfoD3D(id, gpu_info);
-  }
-  return false;
-}
-
-bool CollectDriverInfoD3D(const std::wstring& device_id, GPUInfo* gpu_info) {
-  HMODULE lib_setupapi = LoadLibraryW(L"setupapi.dll");
-  if (!lib_setupapi) {
-    LOG(ERROR) << "Open setupapi.dll failed";
-    return false;
-  }
-  SetupDiGetClassDevsWFunc fp_get_class_devs =
-      reinterpret_cast<SetupDiGetClassDevsWFunc>(
-          GetProcAddress(lib_setupapi, "SetupDiGetClassDevsW"));
-  SetupDiEnumDeviceInfoFunc fp_enum_device_info =
-      reinterpret_cast<SetupDiEnumDeviceInfoFunc>(
-          GetProcAddress(lib_setupapi, "SetupDiEnumDeviceInfo"));
-  SetupDiGetDeviceRegistryPropertyWFunc fp_get_device_registry_property =
-      reinterpret_cast<SetupDiGetDeviceRegistryPropertyWFunc>(
-          GetProcAddress(lib_setupapi, "SetupDiGetDeviceRegistryPropertyW"));
-  SetupDiDestroyDeviceInfoListFunc fp_destroy_device_info_list =
-      reinterpret_cast<SetupDiDestroyDeviceInfoListFunc>(
-          GetProcAddress(lib_setupapi, "SetupDiDestroyDeviceInfoList"));
-  if (!fp_get_class_devs || !fp_enum_device_info ||
-      !fp_get_device_registry_property || !fp_destroy_device_info_list) {
-    FreeLibrary(lib_setupapi);
-    LOG(ERROR) << "Retrieve setupapi.dll functions failed";
-    return false;
-  }
-
-  // create device info for the display device
-  HDEVINFO device_info = fp_get_class_devs(
-    NULL, device_id.c_str(), NULL,
-    DIGCF_PRESENT | DIGCF_PROFILE | DIGCF_ALLCLASSES);
-  if (device_info == INVALID_HANDLE_VALUE) {
-    FreeLibrary(lib_setupapi);
-    LOG(ERROR) << "Creating device info failed";
-    return false;
-  }
-
-  DWORD index = 0;
-  bool found = false;
-  SP_DEVINFO_DATA device_info_data;
-  device_info_data.cbSize = sizeof(device_info_data);
-  while (fp_enum_device_info(device_info, index++, &device_info_data)) {
-    WCHAR value[255];
-    if (fp_get_device_registry_property(device_info,
-                                        &device_info_data,
-                                        SPDRP_DRIVER,
-                                        NULL,
-                                        reinterpret_cast<PBYTE>(value),
-                                        sizeof(value),
-                                        NULL)) {
-      HKEY key;
-      std::wstring driver_key = L"System\\CurrentControlSet\\Control\\Class\\";
-      driver_key += value;
-      LONG result = RegOpenKeyExW(
-          HKEY_LOCAL_MACHINE, driver_key.c_str(), 0, KEY_QUERY_VALUE, &key);
-      if (result == ERROR_SUCCESS) {
-        DWORD dwcb_data = sizeof(value);
-        std::string driver_version;
-        result = RegQueryValueExW(
-            key, L"DriverVersion", NULL, NULL,
-            reinterpret_cast<LPBYTE>(value), &dwcb_data);
-        if (result == ERROR_SUCCESS)
-          driver_version = WideToASCII(std::wstring(value));
-
-        std::string driver_date;
-        dwcb_data = sizeof(value);
-        result = RegQueryValueExW(
-            key, L"DriverDate", NULL, NULL,
-            reinterpret_cast<LPBYTE>(value), &dwcb_data);
-        if (result == ERROR_SUCCESS)
-          driver_date = WideToASCII(std::wstring(value));
-
-        gpu_info->driver_version = driver_version;
-        gpu_info->driver_date = driver_date;
-        found = true;
-        RegCloseKey(key);
-        break;
-      }
-    }
-  }
-  fp_destroy_device_info_list(device_info);
-  FreeLibrary(lib_setupapi);
-  return found;
-}
-
-bool CollectDriverInfoGL(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  std::string gl_version_string = gpu_info->gl_version_string;
-
-  // TODO(zmo): We assume the driver version is in the end of GL_VERSION
-  // string.  Need to verify if it is true for majority drivers.
-
-  size_t pos = gl_version_string.find_last_not_of("0123456789.");
-  if (pos != std::string::npos && pos < gl_version_string.length() - 1) {
-    gpu_info->driver_version = gl_version_string.substr(pos + 1);
-    return true;
-  }
-  return false;
-}
-
-}  // namespace gpu_info_collector
diff --git a/chrome/gpu/gpu_info_unittest_win.cc b/chrome/gpu/gpu_info_unittest_win.cc
deleted file mode 100644
index a6375069..0000000
--- a/chrome/gpu/gpu_info_unittest_win.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-// 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 "base/scoped_ptr.h"
-#include "chrome/gpu/gpu_idirect3d9_mock_win.h"
-#include "chrome/gpu/gpu_info_collector.h"
-#include "content/common/gpu_info.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::_;
-using ::testing::Return;
-using ::testing::SetArgumentPointee;
-
-class GPUInfoTest : public testing::Test {
- public:
-  GPUInfoTest() { }
-  virtual ~GPUInfoTest() { }
-
- protected:
-  void SetUp() {
-    // Test variables taken from Lenovo T61
-    test_identifier_.VendorId = 0x10de;
-    test_identifier_.DeviceId = 0x429;
-    test_identifier_.DriverVersion.QuadPart = 0x6000e000b1e23;  // 6.14.11.7715
-    test_caps_.PixelShaderVersion = 0xffff0300;  // 3.0
-    test_caps_.VertexShaderVersion = 0xfffe0300;  // 3.0
-
-    EXPECT_CALL(d3d_, GetDeviceCaps(_, _, _))
-        .WillOnce(DoAll(SetArgumentPointee<2>(test_caps_),
-                        Return(D3D_OK)));
-    EXPECT_CALL(d3d_, QueryInterface(__uuidof(IDirect3D9Ex), _))
-        .WillOnce(Return(E_NOINTERFACE));
-    EXPECT_CALL(d3d_, Release());
-  }
-  void TearDown() {
-  }
-
- public:
-  IDirect3D9Mock d3d_;
- private:
-  D3DADAPTER_IDENTIFIER9 test_identifier_;
-  D3DCAPS9 test_caps_;
-};
-
-TEST_F(GPUInfoTest, PixelShaderVersionD3D) {
-  GPUInfo gpu_info;
-  ASSERT_TRUE(gpu_info_collector::CollectGraphicsInfoD3D(&d3d_, &gpu_info));
-  uint32 ps_version = gpu_info.pixel_shader_version;
-  EXPECT_EQ(ps_version, D3DPS_VERSION(3, 0));
-}
-
-TEST_F(GPUInfoTest, VertexShaderVersionD3D) {
-  GPUInfo gpu_info;
-  ASSERT_TRUE(gpu_info_collector::CollectGraphicsInfoD3D(&d3d_, &gpu_info));
-  uint32 vs_version = gpu_info.vertex_shader_version;
-  EXPECT_EQ(vs_version, D3DVS_VERSION(3, 0));
-}
diff --git a/chrome/gpu/gpu_main.cc b/chrome/gpu/gpu_main.cc
deleted file mode 100644
index 16a3add..0000000
--- a/chrome/gpu/gpu_main.cc
+++ /dev/null
@@ -1,87 +0,0 @@
-// 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 <stdlib.h>
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
-#include "app/win/scoped_com_initializer.h"
-#include "base/environment.h"
-#include "base/message_loop.h"
-#include "base/stringprintf.h"
-#include "base/threading/platform_thread.h"
-#include "build/build_config.h"
-#include "content/common/content_switches.h"
-#include "content/common/main_function_params.h"
-#include "chrome/gpu/gpu_config.h"
-#include "chrome/gpu/gpu_process.h"
-#include "chrome/gpu/gpu_thread.h"
-
-#if defined(OS_MACOSX)
-#include "content/common/chrome_application_mac.h"
-#endif
-
-#if defined(USE_X11)
-#include "ui/base/x/x11_util.h"
-#endif
-
-// Main function for starting the Gpu process.
-int GpuMain(const MainFunctionParams& parameters) {
-  base::Time start_time = base::Time::Now();
-
-  const CommandLine& command_line = parameters.command_line_;
-  if (command_line.HasSwitch(switches::kGpuStartupDialog)) {
-    ChildProcess::WaitForDebugger("Gpu");
-  }
-
-#if defined(OS_MACOSX)
-  chrome_application_mac::RegisterCrApp();
-#endif
-
-  MessageLoop main_message_loop(MessageLoop::TYPE_UI);
-  base::PlatformThread::SetName("CrGpuMain");
-
-  if (!command_line.HasSwitch(switches::kSingleProcess)) {
-#if defined(OS_WIN)
-    // Prevent Windows from displaying a modal dialog on failures like not being
-    // able to load a DLL.
-    SetErrorMode(
-        SEM_FAILCRITICALERRORS |
-        SEM_NOGPFAULTERRORBOX |
-        SEM_NOOPENFILEERRORBOX);
-#elif defined(USE_X11)
-    ui::SetDefaultX11ErrorHandlers();
-#endif
-  }
-
-  app::win::ScopedCOMInitializer com_initializer;
-
-  // We can not tolerate early returns from this code, because the
-  // detection of early return of a child process is implemented using
-  // an IPC channel error. If the IPC channel is not fully set up
-  // between the browser and GPU process, and the GPU process crashes
-  // or exits early, the browser process will never detect it.  For
-  // this reason we defer all work related to the GPU until receiving
-  // the GpuMsg_Initialize message from the browser.
-  GpuProcess gpu_process;
-
-  GpuThread* gpu_thread =
-#if defined(OS_WIN)
-      new GpuThread(parameters.sandbox_info_.TargetServices());
-#else
-      new GpuThread;
-#endif
-
-  gpu_thread->Init(start_time);
-
-  gpu_process.set_main_thread(gpu_thread);
-
-  main_message_loop.Run();
-
-  gpu_thread->StopWatchdog();
-
-  return 0;
-}
diff --git a/chrome/gpu/gpu_process.cc b/chrome/gpu/gpu_process.cc
deleted file mode 100644
index ada83c8..0000000
--- a/chrome/gpu/gpu_process.cc
+++ /dev/null
@@ -1,11 +0,0 @@
-// 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 "chrome/gpu/gpu_process.h"
-
-GpuProcess::GpuProcess() {
-}
-
-GpuProcess::~GpuProcess() {
-}
diff --git a/chrome/gpu/gpu_process.h b/chrome/gpu/gpu_process.h
deleted file mode 100644
index 7a8caba..0000000
--- a/chrome/gpu/gpu_process.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_GPU_PROCESS_H_
-#define CHROME_GPU_GPU_PROCESS_H_
-#pragma once
-
-#include "content/common/child_process.h"
-
-class GpuProcess : public ChildProcess {
- public:
-  GpuProcess();
-  ~GpuProcess();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(GpuProcess);
-};
-
-#endif  // CHROME_GPU_GPU_PROCESS_H_
diff --git a/chrome/gpu/gpu_thread.cc b/chrome/gpu/gpu_thread.cc
deleted file mode 100644
index a944907..0000000
--- a/chrome/gpu/gpu_thread.cc
+++ /dev/null
@@ -1,347 +0,0 @@
-// 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 "chrome/gpu/gpu_thread.h"
-
-#include <string>
-#include <vector>
-
-#include "app/gfx/gl/gl_context.h"
-#include "app/gfx/gl/gl_implementation.h"
-#include "app/win/scoped_com_initializer.h"
-#include "base/command_line.h"
-#include "base/threading/worker_pool.h"
-#include "build/build_config.h"
-#include "chrome/gpu/gpu_info_collector.h"
-#include "chrome/gpu/gpu_watchdog_thread.h"
-#include "content/common/child_process.h"
-#include "content/common/content_client.h"
-#include "content/common/content_switches.h"
-#include "content/common/gpu_messages.h"
-#include "ipc/ipc_channel_handle.h"
-
-#if defined(OS_MACOSX)
-#include "content/common/sandbox_init_wrapper.h"
-#include "content/common/sandbox_mac.h"
-#elif defined(OS_WIN)
-#include "sandbox/src/sandbox.h"
-#endif
-
-const int kGpuTimeout = 10000;
-
-namespace {
-
-bool InitializeGpuSandbox() {
-#if defined(OS_MACOSX)
-  CommandLine* parsed_command_line = CommandLine::ForCurrentProcess();
-  SandboxInitWrapper sandbox_wrapper;
-  return sandbox_wrapper.InitializeSandbox(*parsed_command_line,
-                                           switches::kGpuProcess);
-#else
-  // TODO(port): Create GPU sandbox for linux.
-  return true;
-#endif
-}
-
-}  // namespace
-
-#if defined(OS_WIN)
-GpuThread::GpuThread(sandbox::TargetServices* target_services)
-    : target_services_(target_services) {
-}
-#else
-GpuThread::GpuThread() {
-}
-#endif
-
-GpuThread::GpuThread(const std::string& channel_id)
-    : ChildThread(channel_id) {
-#if defined(OS_WIN)
-  target_services_ = NULL;
-#endif
-}
-
-
-GpuThread::~GpuThread() {
-  logging::SetLogMessageHandler(NULL);
-}
-
-void GpuThread::Init(const base::Time& process_start_time) {
-  process_start_time_ = process_start_time;
-}
-
-void GpuThread::RemoveChannel(int renderer_id) {
-  gpu_channels_.erase(renderer_id);
-}
-
-bool GpuThread::OnControlMessageReceived(const IPC::Message& msg) {
-  bool msg_is_ok = true;
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP_EX(GpuThread, msg, msg_is_ok)
-    IPC_MESSAGE_HANDLER(GpuMsg_Initialize, OnInitialize)
-    IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
-    IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
-    IPC_MESSAGE_HANDLER(GpuMsg_CreateViewCommandBuffer,
-                        OnCreateViewCommandBuffer);
-    IPC_MESSAGE_HANDLER(GpuMsg_Synchronize, OnSynchronize)
-    IPC_MESSAGE_HANDLER(GpuMsg_CollectGraphicsInfo, OnCollectGraphicsInfo)
-#if defined(OS_MACOSX)
-    IPC_MESSAGE_HANDLER(GpuMsg_AcceleratedSurfaceBuffersSwappedACK,
-                        OnAcceleratedSurfaceBuffersSwappedACK)
-    IPC_MESSAGE_HANDLER(GpuMsg_DidDestroyAcceleratedSurface,
-                        OnDidDestroyAcceleratedSurface)
-#endif
-    IPC_MESSAGE_HANDLER(GpuMsg_Crash, OnCrash)
-    IPC_MESSAGE_HANDLER(GpuMsg_Hang, OnHang)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP_EX()
-  return handled;
-}
-
-namespace {
-
-bool GpuProcessLogMessageHandler(int severity,
-                                 const char* file, int line,
-                                 size_t message_start,
-                                 const std::string& str) {
-  std::string header = str.substr(0, message_start);
-  std::string message = str.substr(message_start);
-  ChildThread::current()->Send(
-      new GpuHostMsg_OnLogMessage(severity, header, message));
-  return false;
-}
-
-}  // namespace
-
-void GpuThread::OnInitialize() {
-  // Redirect LOG messages to the GpuProcessHost
-  bool single_process = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSingleProcess);
-  if (!single_process)
-    logging::SetLogMessageHandler(GpuProcessLogMessageHandler);
-
-  // Load the GL implementation and locate the bindings before starting the GPU
-  // watchdog because this can take a lot of time and the GPU watchdog might
-  // terminate the GPU process.
-  if (!gfx::GLContext::InitializeOneOff()) {
-    LOG(INFO) << "GLContext::InitializeOneOff failed";
-    MessageLoop::current()->Quit();
-    return;
-  }
-  bool gpu_info_result = gpu_info_collector::CollectGraphicsInfo(&gpu_info_);
-  if (!gpu_info_result) {
-    gpu_info_.collection_error = true;
-    LOG(ERROR) << "gpu_info_collector::CollectGraphicsInfo() failed";
-  }
-
-  content::GetContentClient()->SetGpuInfo(gpu_info_);
-  LOG(INFO) << "gpu_info_collector::CollectGraphicsInfo complete";
-
-  // Record initialization only after collecting the GPU info because that can
-  // take a significant amount of time.
-  gpu_info_.initialization_time = base::Time::Now() - process_start_time_;
-
-#if defined (OS_MACOSX)
-  // Note that kNoSandbox will also disable the GPU sandbox.
-  bool no_gpu_sandbox = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kNoGpuSandbox);
-  if (!no_gpu_sandbox) {
-    if (!InitializeGpuSandbox()) {
-      LOG(ERROR) << "Failed to initialize the GPU sandbox";
-      MessageLoop::current()->Quit();
-      return;
-    }
-  } else {
-    LOG(ERROR) << "Running without GPU sandbox";
-  }
-#elif defined(OS_WIN)
-  // For windows, if the target_services interface is not zero, the process
-  // is sandboxed and we must call LowerToken() before rendering untrusted
-  // content.
-  if (target_services_)
-    target_services_->LowerToken();
-#endif
-
-  // In addition to disabling the watchdog if the command line switch is
-  // present, disable it in two other cases. OSMesa is expected to run very
-  // slowly.  Also disable the watchdog on valgrind because the code is expected
-  // to run slowly in that case.
-  bool enable_watchdog =
-      !CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableGpuWatchdog) &&
-      gfx::GetGLImplementation() != gfx::kGLImplementationOSMesaGL &&
-      !RunningOnValgrind();
-
-  // Disable the watchdog in debug builds because they tend to only be run by
-  // developers who will not appreciate the watchdog killing the GPU process.
-#ifndef NDEBUG
-  enable_watchdog = false;
-#endif
-
-  // Disable the watchdog for Windows. It tends to abort when the GPU process
-  // is not hung but still taking a long time to do something. Instead, the
-  // browser process displays a dialog when it notices that the child window
-  // is hung giving the user an opportunity to terminate it. This is the
-  // same mechanism used to abort hung plugins.
-#if defined(OS_WIN)
-  enable_watchdog = false;
-#endif
-
-  // Start the GPU watchdog only after anything that is expected to be time
-  // consuming has completed, otherwise the process is liable to be aborted.
-  if (enable_watchdog) {
-    watchdog_thread_ = new GpuWatchdogThread(kGpuTimeout);
-    watchdog_thread_->Start();
-  }
-}
-
-void GpuThread::StopWatchdog() {
-  if (watchdog_thread_.get()) {
-    watchdog_thread_->Stop();
-  }
-}
-
-void GpuThread::OnEstablishChannel(int renderer_id) {
-  scoped_refptr<GpuChannel> channel;
-  IPC::ChannelHandle channel_handle;
-  GPUInfo gpu_info;
-
-  GpuChannelMap::const_iterator iter = gpu_channels_.find(renderer_id);
-  if (iter == gpu_channels_.end())
-    channel = new GpuChannel(this, renderer_id);
-  else
-    channel = iter->second;
-
-  DCHECK(channel != NULL);
-
-  if (channel->Init())
-    gpu_channels_[renderer_id] = channel;
-  else
-    channel = NULL;
-
-  if (channel.get()) {
-    channel_handle.name = channel->GetChannelName();
-#if defined(OS_POSIX)
-    // On POSIX, pass the renderer-side FD. Also mark it as auto-close so
-    // that it gets closed after it has been sent.
-    int renderer_fd = channel->GetRendererFileDescriptor();
-    channel_handle.socket = base::FileDescriptor(renderer_fd, false);
-#endif
-  }
-
-  Send(new GpuHostMsg_ChannelEstablished(channel_handle, gpu_info_));
-}
-
-void GpuThread::OnCloseChannel(const IPC::ChannelHandle& channel_handle) {
-  for (GpuChannelMap::iterator iter = gpu_channels_.begin();
-       iter != gpu_channels_.end(); ++iter) {
-    if (iter->second->GetChannelName() == channel_handle.name) {
-      gpu_channels_.erase(iter);
-      return;
-    }
-  }
-}
-
-void GpuThread::OnSynchronize() {
-  Send(new GpuHostMsg_SynchronizeReply());
-}
-
-void GpuThread::OnCollectGraphicsInfo(GPUInfo::Level level) {
-#if defined(OS_WIN)
-  if (level == GPUInfo::kComplete && gpu_info_.level <= GPUInfo::kPartial) {
-    // Prevent concurrent collection of DirectX diagnostics.
-    gpu_info_.level = GPUInfo::kCompleting;
-
-    // Asynchronously collect the DirectX diagnostics because this can take a
-    // couple of seconds.
-    if (!base::WorkerPool::PostTask(
-        FROM_HERE,
-        NewRunnableFunction(&GpuThread::CollectDxDiagnostics, this),
-        true)) {
-
-      // Flag GPU info as complete if the DirectX diagnostics cannot be
-      // collected.
-      gpu_info_.level = GPUInfo::kComplete;
-    } else {
-      // Do not send response if we are still completing the GPUInfo struct
-      return;
-    }
-  }
-#endif
-  Send(new GpuHostMsg_GraphicsInfoCollected(gpu_info_));
-}
-
-void GpuThread::OnCreateViewCommandBuffer(
-    gfx::PluginWindowHandle window,
-    int32 render_view_id,
-    int32 renderer_id,
-    const GPUCreateCommandBufferConfig& init_params) {
-  int32 route_id = MSG_ROUTING_NONE;
-
-  GpuChannelMap::const_iterator iter = gpu_channels_.find(renderer_id);
-  if (iter != gpu_channels_.end()) {
-    iter->second->CreateViewCommandBuffer(
-        window, render_view_id, init_params, &route_id);
-  }
-
-  Send(new GpuHostMsg_CommandBufferCreated(route_id));
-}
-
-#if defined(OS_MACOSX)
-void GpuThread::OnAcceleratedSurfaceBuffersSwappedACK(
-    int renderer_id, int32 route_id, uint64 swap_buffers_count) {
-  GpuChannelMap::const_iterator iter = gpu_channels_.find(renderer_id);
-  if (iter == gpu_channels_.end())
-    return;
-  scoped_refptr<GpuChannel> channel = iter->second;
-  channel->AcceleratedSurfaceBuffersSwapped(route_id, swap_buffers_count);
-}
-void GpuThread::OnDidDestroyAcceleratedSurface(
-    int renderer_id, int32 renderer_route_id) {
-  GpuChannelMap::const_iterator iter = gpu_channels_.find(renderer_id);
-  if (iter == gpu_channels_.end())
-    return;
-  scoped_refptr<GpuChannel> channel = iter->second;
-  channel->DidDestroySurface(renderer_route_id);
-}
-#endif
-
-void GpuThread::OnCrash() {
-  LOG(INFO) << "GPU: Simulating GPU crash";
-  // Good bye, cruel world.
-  volatile int* it_s_the_end_of_the_world_as_we_know_it = NULL;
-  *it_s_the_end_of_the_world_as_we_know_it = 0xdead;
-}
-
-void GpuThread::OnHang() {
-  LOG(INFO) << "GPU: Simulating GPU hang";
-  for (;;) {
-    // Do not sleep here. The GPU watchdog timer tracks the amount of user
-    // time this thread is using and it doesn't use much while calling Sleep.
-  }
-}
-
-#if defined(OS_WIN)
-
-// Runs on a worker thread. The GpuThread never terminates voluntarily so it is
-// safe to assume that its message loop is valid.
-void GpuThread::CollectDxDiagnostics(GpuThread* thread) {
-  app::win::ScopedCOMInitializer com_initializer;
-
-  DxDiagNode node;
-  gpu_info_collector::GetDxDiagnostics(&node);
-
-  thread->message_loop()->PostTask(
-      FROM_HERE,
-      NewRunnableFunction(&GpuThread::SetDxDiagnostics, thread, node));
-}
-
-// Runs on the GPU thread.
-void GpuThread::SetDxDiagnostics(GpuThread* thread, const DxDiagNode& node) {
-  thread->gpu_info_.dx_diagnostics = node;
-  thread->gpu_info_.level = GPUInfo::kComplete;
-  thread->Send(new GpuHostMsg_GraphicsInfoCollected(thread->gpu_info_));
-}
-
-#endif
diff --git a/chrome/gpu/gpu_thread.h b/chrome/gpu/gpu_thread.h
deleted file mode 100644
index 7c3cef4..0000000
--- a/chrome/gpu/gpu_thread.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_GPU_THREAD_H_
-#define CHROME_GPU_GPU_THREAD_H_
-#pragma once
-
-#include <string>
-
-#include "base/basictypes.h"
-#include "base/command_line.h"
-#include "base/scoped_ptr.h"
-#include "base/time.h"
-#include "build/build_config.h"
-#include "chrome/gpu/gpu_channel.h"
-#include "chrome/gpu/gpu_config.h"
-#include "chrome/gpu/x_util.h"
-#include "content/common/child_thread.h"
-#include "content/common/gpu_info.h"
-#include "ui/gfx/native_widget_types.h"
-
-namespace IPC {
-struct ChannelHandle;
-}
-
-namespace sandbox {
-class TargetServices;
-}
-
-class GpuWatchdogThread;
-
-class GpuThread : public ChildThread {
- public:
-#if defined(OS_WIN)
-  explicit GpuThread(sandbox::TargetServices* target_services);
-#else
-  GpuThread();
-#endif
-
-  // For single-process mode.
-  explicit GpuThread(const std::string& channel_id);
-
-  ~GpuThread();
-
-  void Init(const base::Time& process_start_time);
-  void StopWatchdog();
-
-  // Remove the channel for a particular renderer.
-  void RemoveChannel(int renderer_id);
-
- private:
-  // ChildThread overrides.
-  virtual bool OnControlMessageReceived(const IPC::Message& msg);
-
-  // Message handlers.
-  void OnInitialize();
-  void OnEstablishChannel(int renderer_id);
-  void OnCloseChannel(const IPC::ChannelHandle& channel_handle);
-  void OnSynchronize();
-  void OnCollectGraphicsInfo(GPUInfo::Level level);
-  void OnCreateViewCommandBuffer(
-      gfx::PluginWindowHandle window,
-      int32 render_view_id,
-      int32 renderer_id,
-      const GPUCreateCommandBufferConfig& init_params);
-#if defined(OS_MACOSX)
-  void OnAcceleratedSurfaceBuffersSwappedACK(
-      int renderer_id, int32 route_id, uint64 swap_buffers_count);
-  void OnDidDestroyAcceleratedSurface(int renderer_id, int32 renderer_route_id);
-#endif
-  void OnCrash();
-  void OnHang();
-
-#if defined(OS_WIN)
-  static void CollectDxDiagnostics(GpuThread* thread);
-  static void SetDxDiagnostics(GpuThread* thread, const DxDiagNode& node);
-#endif
-
-  base::Time process_start_time_;
-  scoped_refptr<GpuWatchdogThread> watchdog_thread_;
-
-  typedef base::hash_map<int, scoped_refptr<GpuChannel> > GpuChannelMap;
-  GpuChannelMap gpu_channels_;
-
-  // Information about the GPU, such as device and vendor ID.
-  GPUInfo gpu_info_;
-
-#if defined(OS_WIN)
-  // Windows specific client sandbox interface.
-  sandbox::TargetServices* target_services_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(GpuThread);
-};
-
-#endif  // CHROME_GPU_GPU_THREAD_H_
diff --git a/chrome/gpu/gpu_video_decoder.cc b/chrome/gpu/gpu_video_decoder.cc
deleted file mode 100644
index 96be0c3..0000000
--- a/chrome/gpu/gpu_video_decoder.cc
+++ /dev/null
@@ -1,427 +0,0 @@
-// 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 "chrome/gpu/gpu_video_decoder.h"
-
-#include "base/command_line.h"
-#include "chrome/gpu/gpu_channel.h"
-#include "chrome/gpu/media/fake_gl_video_decode_engine.h"
-#include "chrome/gpu/media/fake_gl_video_device.h"
-#include "content/common/child_thread.h"
-#include "content/common/gpu_messages.h"
-#include "media/base/data_buffer.h"
-#include "media/base/media_switches.h"
-#include "media/base/video_frame.h"
-
-#if defined(OS_WIN)
-#include "chrome/gpu/media/mft_angle_video_device.h"
-#include "media/video/mft_h264_decode_engine.h"
-#include <d3d9.h>
-#endif
-
-struct GpuVideoDecoder::PendingAllocation {
-  size_t n;
-  size_t width;
-  size_t height;
-  media::VideoFrame::Format format;
-  std::vector<scoped_refptr<media::VideoFrame> >* frames;
-  Task* task;
-};
-
-void GpuVideoDecoder::OnChannelConnected(int32 peer_pid) {
-}
-
-void GpuVideoDecoder::OnChannelError() {
-}
-
-bool GpuVideoDecoder::OnMessageReceived(const IPC::Message& msg) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(GpuVideoDecoder, msg)
-    IPC_MESSAGE_HANDLER(GpuVideoDecoderMsg_Initialize,
-                        OnInitialize)
-    IPC_MESSAGE_HANDLER(GpuVideoDecoderMsg_Destroy,
-                        OnUninitialize)
-    IPC_MESSAGE_HANDLER(GpuVideoDecoderMsg_Flush,
-                        OnFlush)
-    IPC_MESSAGE_HANDLER(GpuVideoDecoderMsg_Preroll,
-                        OnPreroll)
-    IPC_MESSAGE_HANDLER(GpuVideoDecoderMsg_EmptyThisBuffer,
-                        OnEmptyThisBuffer)
-    IPC_MESSAGE_HANDLER(GpuVideoDecoderMsg_ProduceVideoFrame,
-                        OnProduceVideoFrame)
-    IPC_MESSAGE_HANDLER(GpuVideoDecoderMsg_VideoFrameAllocated,
-                        OnVideoFrameAllocated)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  DCHECK(handled);
-  return handled;
-}
-
-bool GpuVideoDecoder::CreateInputTransferBuffer(
-    uint32 size,
-    base::SharedMemoryHandle* handle) {
-  input_transfer_buffer_.reset(new base::SharedMemory);
-  if (!input_transfer_buffer_.get())
-    return false;
-
-  if (!input_transfer_buffer_->CreateAndMapAnonymous(size))
-    return false;
-
-  if (!input_transfer_buffer_->ShareToProcess(renderer_handle_, handle))
-    return false;
-
-  return true;
-}
-
-void GpuVideoDecoder::OnInitializeComplete(const VideoCodecInfo& info) {
-  info_ = info;
-  GpuVideoDecoderInitDoneParam param;
-  param.success = false;
-  param.input_buffer_handle = base::SharedMemory::NULLHandle();
-
-  if (!info.success) {
-    SendInitializeDone(param);
-    return;
-  }
-
-  // TODO(jiesun): Check the assumption of input size < original size.
-  param.input_buffer_size =
-      info.stream_info.surface_width * info.stream_info.surface_height * 3 / 2;
-  if (!CreateInputTransferBuffer(param.input_buffer_size,
-                                 &param.input_buffer_handle)) {
-    SendInitializeDone(param);
-    return;
-  }
-
-  param.success = true;
-  SendInitializeDone(param);
-}
-
-void GpuVideoDecoder::OnUninitializeComplete() {
-  SendUninitializeDone();
-}
-
-void GpuVideoDecoder::OnFlushComplete() {
-  SendFlushDone();
-}
-
-void GpuVideoDecoder::OnSeekComplete() {
-  SendPrerollDone();
-}
-
-void GpuVideoDecoder::OnError() {
-  NOTIMPLEMENTED();
-}
-
-void GpuVideoDecoder::OnFormatChange(VideoStreamInfo stream_info) {
-  NOTIMPLEMENTED();
-}
-
-void GpuVideoDecoder::ProduceVideoSample(scoped_refptr<Buffer> buffer) {
-  SendEmptyBufferDone();
-}
-
-void GpuVideoDecoder::ConsumeVideoFrame(scoped_refptr<VideoFrame> frame,
-                                        const PipelineStatistics& statistics) {
-  // TODO(sjl): Do something with the statistics...
-
-  if (frame->IsEndOfStream()) {
-    SendConsumeVideoFrame(0, 0, 0, kGpuVideoEndOfStream);
-    return;
-  }
-
-  int32 frame_id = -1;
-  for (VideoFrameMap::iterator i = video_frame_map_.begin();
-       i != video_frame_map_.end(); ++i) {
-    if (i->second == frame) {
-      frame_id = i->first;
-      break;
-    }
-  }
-
-  if (frame_id == -1) {
-    NOTREACHED() << "VideoFrame not recognized";
-    return;
-  }
-
-  SendConsumeVideoFrame(frame_id, frame->GetTimestamp().InMicroseconds(),
-                        frame->GetDuration().InMicroseconds(), 0);
-}
-
-void* GpuVideoDecoder::GetDevice() {
-  bool ret = gles2_decoder_->MakeCurrent();
-  DCHECK(ret) << "Failed to switch context";
-
-  // Simply delegate the method call to GpuVideoDevice.
-  return video_device_->GetDevice();
-}
-
-void GpuVideoDecoder::AllocateVideoFrames(
-    int n, size_t width, size_t height, media::VideoFrame::Format format,
-    std::vector<scoped_refptr<media::VideoFrame> >* frames, Task* task) {
-  // Since the communication between Renderer and GPU process is by GL textures.
-  // We need to obtain a set of GL textures by sending IPC commands to the
-  // Renderer process. The recipient of these commands will be IpcVideoDecoder.
-  //
-  // After IpcVideoDecoder replied with a set of textures. We'll assign these
-  // textures to GpuVideoDevice. They will be used to generate platform
-  // specific VideoFrames objects that are used by VideoDecodeEngine.
-  //
-  // After GL textures are assigned we'll proceed with allocation the
-  // VideoFrames. GpuVideoDevice::CreateVideoFramesFromGlTextures() will be
-  // called.
-  //
-  // When GpuVideoDevice replied with a set of VideoFrames we'll give
-  // that to VideoDecodeEngine and the cycle of video frame allocation is done.
-  //
-  // Note that this method is called when there's no video frames allocated or
-  // they were all released.
-  DCHECK(video_frame_map_.empty());
-
-  // Save the parameters for allocation.
-  pending_allocation_.reset(new PendingAllocation());
-  pending_allocation_->n = n;
-  pending_allocation_->width = width;
-  pending_allocation_->height = height;
-  pending_allocation_->format = format;
-  pending_allocation_->frames = frames;
-  pending_allocation_->task = task;
-  SendAllocateVideoFrames(n, width, height, format);
-}
-
-void GpuVideoDecoder::ReleaseAllVideoFrames() {
-  // This method will first call to GpuVideoDevice to release all the resource
-  // associated with a VideoFrame.
-  //
-  // And then we'll call GpuVideoDevice::ReleaseVideoFrame() to remove the set
-  // of Gl textures associated with the context.
-  //
-  // And finally we'll send IPC commands to IpcVideoDecoder to destroy all
-  // GL textures generated.
-  bool ret = gles2_decoder_->MakeCurrent();
-  DCHECK(ret) << "Failed to switch context";
-
-  for (VideoFrameMap::iterator i = video_frame_map_.begin();
-       i != video_frame_map_.end(); ++i) {
-    video_device_->ReleaseVideoFrame(i->second);
-  }
-  video_frame_map_.clear();
-  SendReleaseAllVideoFrames();
-}
-
-void GpuVideoDecoder::ConvertToVideoFrame(
-    void* buffer,
-    scoped_refptr<media::VideoFrame> frame,
-    Task* task) {
-  // This method is called by VideoDecodeEngine to upload a buffer to a
-  // VideoFrame. We should just delegate this to GpuVideoDevice which contains
-  // the actual implementation.
-  bool ret = gles2_decoder_->MakeCurrent();
-  DCHECK(ret) << "Failed to switch context";
-
-  // Actually doing the upload on the main thread.
-  ret = video_device_->ConvertToVideoFrame(buffer, frame);
-  DCHECK(ret) << "Failed to upload video content to a VideoFrame.";
-  task->Run();
-  delete task;
-}
-
-void GpuVideoDecoder::Destroy(Task* task) {
-  //  TODO(hclam): I still need to think what I should do here.
-}
-
-void GpuVideoDecoder::SetVideoDecodeEngine(media::VideoDecodeEngine* engine) {
-  decode_engine_.reset(engine);
-}
-
-void GpuVideoDecoder::SetGpuVideoDevice(GpuVideoDevice* device) {
-  video_device_.reset(device);
-}
-
-GpuVideoDecoder::GpuVideoDecoder(
-    MessageLoop* message_loop,
-    int32 decoder_host_id,
-    IPC::Message::Sender* sender,
-    base::ProcessHandle handle,
-    gpu::gles2::GLES2Decoder* decoder)
-    : message_loop_(message_loop),
-      decoder_host_id_(decoder_host_id),
-      sender_(sender),
-      renderer_handle_(handle),
-      gles2_decoder_(decoder) {
-  memset(&info_, 0, sizeof(info_));
-
-  // TODO(jiesun): find a better way to determine which VideoDecodeEngine
-  // to return on current platform.
-#if defined(OS_WIN)
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch(switches::kEnableAcceleratedDecoding)) {
-    // The following code are removed so that we don't link them.
-    // TODO(hclam): Enable the code once the crash is solved on XP.
-    // decode_engine_.reset(new media::MftH264DecodeEngine(true));
-    // video_device_.reset(new MftAngleVideoDevice());
-  }
-#else
-  decode_engine_.reset(new FakeGlVideoDecodeEngine());
-  video_device_.reset(new FakeGlVideoDevice());
-#endif
-}
-
-GpuVideoDecoder::~GpuVideoDecoder() {}
-
-void GpuVideoDecoder::OnInitialize(const GpuVideoDecoderInitParam& param) {
-  // TODO(jiesun): codec id should come from |param|.
-  media::VideoCodecConfig config(media::kCodecH264,
-                                 param.width,
-                                 param.height,
-                                 param.frame_rate_num,
-                                 param.frame_rate_den,
-                                 NULL,
-                                 0);
-  decode_engine_->Initialize(message_loop_, this, this, config);
-}
-
-void GpuVideoDecoder::OnUninitialize() {
-  decode_engine_->Uninitialize();
-}
-
-void GpuVideoDecoder::OnFlush() {
-  decode_engine_->Flush();
-}
-
-void GpuVideoDecoder::OnPreroll() {
-  decode_engine_->Seek();
-}
-
-void GpuVideoDecoder::OnEmptyThisBuffer(
-    const GpuVideoDecoderInputBufferParam& buffer) {
-  DCHECK(input_transfer_buffer_->memory());
-
-  uint8* src = static_cast<uint8*>(input_transfer_buffer_->memory());
-
-  scoped_refptr<Buffer> input_buffer;
-  uint8* dst = buffer.size ? new uint8[buffer.size] : NULL;
-  input_buffer = new media::DataBuffer(dst, buffer.size);
-  memcpy(dst, src, buffer.size);
-  SendEmptyBufferACK();
-
-  // Delegate the method call to VideoDecodeEngine.
-  decode_engine_->ConsumeVideoSample(input_buffer);
-}
-
-void GpuVideoDecoder::OnProduceVideoFrame(int32 frame_id) {
-  VideoFrameMap::iterator i = video_frame_map_.find(frame_id);
-  if (i == video_frame_map_.end()) {
-    NOTREACHED() << "Received a request of unknown frame ID.";
-  }
-
-  // Delegate the method call to VideoDecodeEngine.
-  decode_engine_->ProduceVideoFrame(i->second);
-}
-
-void GpuVideoDecoder::OnVideoFrameAllocated(int32 frame_id,
-                                            std::vector<uint32> textures) {
-  bool ret = gles2_decoder_->MakeCurrent();
-  DCHECK(ret) << "Failed to switch context";
-
-  // This method is called in response to a video frame allocation request sent
-  // to the Renderer process.
-  // We should use the textures to generate a VideoFrame by using
-  // GpuVideoDevice. The VideoFrame created is added to the internal map.
-  // If we have generated enough VideoFrame, we call |allocation_callack_| to
-  // complete the allocation process.
-  for (size_t i = 0; i < textures.size(); ++i) {
-    media::VideoFrame::GlTexture gl_texture;
-    // Translate the client texture id to service texture id.
-    ret = gles2_decoder_->GetServiceTextureId(textures[i], &gl_texture);
-    DCHECK(ret) << "Cannot translate client texture ID to service ID";
-    textures[i] = gl_texture;
-  }
-
-  // Use GpuVideoDevice to allocate VideoFrame objects.
-  scoped_refptr<media::VideoFrame> frame;
-
-  ret = video_device_->CreateVideoFrameFromGlTextures(
-      pending_allocation_->width, pending_allocation_->height,
-      pending_allocation_->format, textures, &frame);
-
-  DCHECK(ret) << "Failed to allocation VideoFrame from GL textures)";
-  pending_allocation_->frames->push_back(frame);
-  video_frame_map_.insert(std::make_pair(frame_id, frame));
-
-  if (video_frame_map_.size() == pending_allocation_->n) {
-    pending_allocation_->task->Run();
-    delete pending_allocation_->task;
-    pending_allocation_.reset();
-  }
-}
-
-void GpuVideoDecoder::SendInitializeDone(
-    const GpuVideoDecoderInitDoneParam& param) {
-  if (!sender_->Send(
-          new GpuVideoDecoderHostMsg_InitializeACK(decoder_host_id(), param))) {
-    LOG(ERROR) << "GpuVideoDecoderMsg_InitializeACK failed";
-  }
-}
-
-void GpuVideoDecoder::SendUninitializeDone() {
-  if (!sender_->Send(
-          new GpuVideoDecoderHostMsg_DestroyACK(decoder_host_id()))) {
-    LOG(ERROR) << "GpuVideoDecoderMsg_DestroyACK failed";
-  }
-}
-
-void GpuVideoDecoder::SendFlushDone() {
-  if (!sender_->Send(new GpuVideoDecoderHostMsg_FlushACK(decoder_host_id()))) {
-    LOG(ERROR) << "GpuVideoDecoderMsg_FlushACK failed";
-  }
-}
-
-void GpuVideoDecoder::SendPrerollDone() {
-  if (!sender_->Send(new GpuVideoDecoderHostMsg_PrerollDone(
-          decoder_host_id()))) {
-    LOG(ERROR) << "GpuVideoDecoderMsg_PrerollDone failed";
-  }
-}
-
-void GpuVideoDecoder::SendEmptyBufferDone() {
-  if (!sender_->Send(
-          new GpuVideoDecoderHostMsg_EmptyThisBufferDone(decoder_host_id()))) {
-    LOG(ERROR) << "GpuVideoDecoderMsg_EmptyThisBufferDone failed";
-  }
-}
-
-void GpuVideoDecoder::SendEmptyBufferACK() {
-  if (!sender_->Send(
-          new GpuVideoDecoderHostMsg_EmptyThisBufferACK(decoder_host_id()))) {
-    LOG(ERROR) << "GpuVideoDecoderMsg_EmptyThisBufferACK failed";
-  }
-}
-
-void GpuVideoDecoder::SendConsumeVideoFrame(
-    int32 frame_id, int64 timestamp, int64 duration, int32 flags) {
-  if (!sender_->Send(
-          new GpuVideoDecoderHostMsg_ConsumeVideoFrame(
-              decoder_host_id(), frame_id, timestamp, duration, flags))) {
-    LOG(ERROR) << "GpuVideoDecodeHostMsg_ConsumeVideoFrame failed.";
-  }
-}
-
-void GpuVideoDecoder::SendAllocateVideoFrames(
-    int n, size_t width, size_t height, media::VideoFrame::Format format) {
-  if (!sender_->Send(
-          new GpuVideoDecoderHostMsg_AllocateVideoFrames(
-              decoder_host_id(), n, width, height,
-              static_cast<int32>(format)))) {
-    LOG(ERROR) << "GpuVideoDecoderMsg_AllocateVideoFrames failed";
-  }
-}
-
-void GpuVideoDecoder::SendReleaseAllVideoFrames() {
-  if (!sender_->Send(
-          new GpuVideoDecoderHostMsg_ReleaseAllVideoFrames(
-              decoder_host_id()))) {
-    LOG(ERROR) << "GpuVideoDecoderMsg_ReleaseAllVideoFrames failed";
-  }
-}
diff --git a/chrome/gpu/gpu_video_decoder.h b/chrome/gpu/gpu_video_decoder.h
deleted file mode 100644
index 92bbb70..0000000
--- a/chrome/gpu/gpu_video_decoder.h
+++ /dev/null
@@ -1,209 +0,0 @@
-// 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 CHROME_GPU_GPU_VIDEO_DECODER_H_
-#define CHROME_GPU_GPU_VIDEO_DECODER_H_
-
-#include <map>
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/callback.h"
-#include "base/process.h"
-#include "base/ref_counted.h"
-#include "base/scoped_ptr.h"
-#include "base/shared_memory.h"
-#include "chrome/gpu/media/gpu_video_device.h"
-#include "media/video/video_decode_context.h"
-#include "media/video/video_decode_engine.h"
-#include "ipc/ipc_channel.h"
-
-using media::Buffer;
-using media::PipelineStatistics;
-using media::VideoCodecConfig;
-using media::VideoCodecInfo;
-using media::VideoStreamInfo;
-using media::VideoFrame;
-
-namespace gpu {
-namespace gles2 {
-class GLES2Decoder;
-}  // namespace gles2
-}  // namespace gpu
-
-class GpuChannel;
-struct GpuVideoDecoderInitDoneParam;
-struct GpuVideoDecoderInitParam;
-struct GpuVideoDecoderInputBufferParam;
-
-// A GpuVideoDecoder is a platform independent video decoder that uses platform
-// specific VideoDecodeEngine and GpuVideoDevice for the actual decoding
-// operations.
-//
-// In addition to delegating video related commamnds to VideoDecodeEngine it
-// has the following important functions:
-//
-// BUFFER ALLOCATION
-//
-// VideoDecodeEngine requires platform specific video frame buffer to operate.
-// In order to abstract the platform specific bits GpuVideoDecoderContext is
-// used to allocate video frames that a VideoDecodeEngine can use.
-//
-// Since all the video frames appear to the Renderer process as textures, the
-// first thing GpuVideoDecoder needs to do is to ask Renderer process to
-// generate and allocate textures. This will establish a texture record in the
-// command buffer decoder. After the texture is allocated, this class will
-// pass the textures meaningful in the local GLES context to
-// GpuVideoDevice for generating VideoFrames that VideoDecodeEngine
-// can actually use.
-//
-// In order to coordinate these operations, GpuVideoDecoder implements
-// VideoDecodeContext and is injected into the VideoDecodeEngine.
-//
-// The sequence of operations is:
-// 1. VideoDecodeEngine requests by call AllocateVideoFrames().
-// 2. GpuVideoDecoder receives AllocateVideoFrames() and then call to the
-//    Renderer process to generate textures.
-// 3. Renderer process replied with textures.
-// 4. Textures generated are passed into GpuVideoDevice.
-// 5. GpuVideoDevice::AllocateVideoFrames() is called to generate
-//    VideoFrame(s) from the textures.
-// 6. GpuVideoDecoder sends the VideoFrame(s) generated to VideoDecodeEngine.
-//
-// BUFFER UPLOADING
-//
-// A VideoDecodeEngine always produces some device specific buffer. In order to
-// use them in Chrome we always upload them to GL textures. The upload step is
-// different on each platform and each subsystem. We perform these special
-// upload steps by using GpuVideoDevice which are written for each
-// VideoDecodeEngine.
-//
-// BUFFER MAPPING
-//
-// GpuVideoDecoder will be working with VideoDecodeEngine, they exchange
-// buffers that are only meaningful to VideoDecodeEngine. In order to map that
-// to something we can transport in the IPC channel we need a mapping between
-// VideoFrame and buffer ID known between GpuVideoDecoder and
-// GpuVideoDecoderHost in the Renderer process.
-//
-// After texture allocation and VideoFrame allocation are done, GpuVideoDecoder
-// will maintain such mapping.
-//
-class GpuVideoDecoder
-    : public base::RefCountedThreadSafe<GpuVideoDecoder>,
-      public IPC::Channel::Listener,
-      public media::VideoDecodeEngine::EventHandler,
-      public media::VideoDecodeContext {
- public:
-  // Constructor and destructor.
-  GpuVideoDecoder(MessageLoop* message_loop,
-                  int32 decoder_host_id,
-                  IPC::Message::Sender* sender,
-                  base::ProcessHandle handle,
-                  gpu::gles2::GLES2Decoder* decoder);
-  virtual ~GpuVideoDecoder();
-
-  // IPC::Channel::Listener implementation.
-  virtual void OnChannelConnected(int32 peer_pid);
-  virtual void OnChannelError();
-  virtual bool OnMessageReceived(const IPC::Message& message);
-
-  // VideoDecodeEngine::EventHandler implementation.
-  virtual void OnInitializeComplete(const VideoCodecInfo& info);
-  virtual void OnUninitializeComplete();
-  virtual void OnFlushComplete();
-  virtual void OnSeekComplete();
-  virtual void OnError();
-  virtual void OnFormatChange(VideoStreamInfo stream_info);
-  virtual void ProduceVideoSample(scoped_refptr<Buffer> buffer);
-  virtual void ConsumeVideoFrame(scoped_refptr<VideoFrame> frame,
-                                 const PipelineStatistics& statistics);
-
-  // VideoDecodeContext implementation.
-  virtual void* GetDevice();
-  virtual void AllocateVideoFrames(
-      int n, size_t width, size_t height, media::VideoFrame::Format format,
-      std::vector<scoped_refptr<media::VideoFrame> >* frames, Task* task);
-  virtual void ReleaseAllVideoFrames();
-  virtual void ConvertToVideoFrame(void* buffer,
-                                   scoped_refptr<media::VideoFrame> frame,
-                                   Task* task);
-  virtual void Destroy(Task* task);
-
-  // These methods are used in unit test only.
-  void SetVideoDecodeEngine(media::VideoDecodeEngine* engine);
-  void SetGpuVideoDevice(GpuVideoDevice* device);
-
- private:
-  struct PendingAllocation;
-
-  int32 decoder_host_id() { return decoder_host_id_; }
-
-  bool CreateInputTransferBuffer(uint32 size,
-                                 base::SharedMemoryHandle* handle);
-
-  // These methods are message handlers for the messages sent from the Renderer
-  // process.
-  void OnInitialize(const GpuVideoDecoderInitParam& param);
-  void OnUninitialize();
-  void OnFlush();
-  void OnPreroll();
-  void OnEmptyThisBuffer(const GpuVideoDecoderInputBufferParam& buffer);
-  void OnProduceVideoFrame(int32 frame_id);
-  void OnVideoFrameAllocated(int32 frame_id, std::vector<uint32> textures);
-
-  // Helper methods for sending messages to the Renderer process.
-  void SendInitializeDone(const GpuVideoDecoderInitDoneParam& param);
-  void SendUninitializeDone();
-  void SendFlushDone();
-  void SendPrerollDone();
-  void SendEmptyBufferDone();
-  void SendEmptyBufferACK();
-  void SendConsumeVideoFrame(int32 frame_id, int64 timestamp, int64 duration,
-                             int32 flags);
-  void SendAllocateVideoFrames(
-      int n, size_t width, size_t height, media::VideoFrame::Format format);
-  void SendReleaseAllVideoFrames();
-
-  // The message loop that this object should run on.
-  MessageLoop* message_loop_;
-
-  // ID of GpuVideoDecoderHost in the Renderer Process.
-  int32 decoder_host_id_;
-
-  // Used only in system memory path. i.e. Remove this later.
-  scoped_refptr<VideoFrame> frame_;
-
-  IPC::Message::Sender* sender_;
-  base::ProcessHandle renderer_handle_;
-
-  // The GLES2 decoder has the context associated with this decoder. This object
-  // is used to switch context and translate client texture ID to service ID.
-  gpu::gles2::GLES2Decoder* gles2_decoder_;
-
-  // Memory for transfering the input data for the hardware video decoder.
-  scoped_ptr<base::SharedMemory> input_transfer_buffer_;
-
-  // VideoDecodeEngine is used to do the actual video decoding.
-  scoped_ptr<media::VideoDecodeEngine> decode_engine_;
-
-  // GpuVideoDevice is used to generate VideoFrame(s) from GL textures. The
-  // frames generated are understood by the decode engine.
-  scoped_ptr<GpuVideoDevice> video_device_;
-
-  // Contain information for allocation VideoFrame(s).
-  scoped_ptr<PendingAllocation> pending_allocation_;
-
-  // Contains the mapping between a |frame_id| and VideoFrame generated by
-  // GpuVideoDevice from the associated GL textures.
-  // TODO(hclam): Using a faster data structure than map.
-  typedef std::map<int32, scoped_refptr<media::VideoFrame> > VideoFrameMap;
-  VideoFrameMap video_frame_map_;
-
-  media::VideoCodecInfo info_;
-
-  DISALLOW_COPY_AND_ASSIGN(GpuVideoDecoder);
-};
-
-#endif  // CHROME_GPU_GPU_VIDEO_DECODER_H_
diff --git a/chrome/gpu/gpu_video_decoder_unittest.cc b/chrome/gpu/gpu_video_decoder_unittest.cc
deleted file mode 100644
index 4b8b18f..0000000
--- a/chrome/gpu/gpu_video_decoder_unittest.cc
+++ /dev/null
@@ -1,264 +0,0 @@
-// 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 "base/message_loop.h"
-#include "base/process.h"
-#include "chrome/gpu/gpu_video_decoder.h"
-#include "content/common/gpu_messages.h"
-#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
-#include "ipc/ipc_message_utils.h"
-#include "media/base/pipeline.h"
-#include "media/video/video_mock_objects.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using testing::_;
-using testing::DoAll;
-using testing::NotNull;
-using testing::Return;
-using testing::SetArgumentPointee;
-
-static const int32 kFrameId = 10;
-static const int32 kDecoderHostId = 50;
-static const media::VideoFrame::GlTexture kClientTexture = 101;
-static const media::VideoFrame::GlTexture kServiceTexture = 102;
-static const size_t kWidth = 320;
-static const size_t kHeight = 240;
-
-class MockGpuVideoDevice : public GpuVideoDevice {
- public:
-  MockGpuVideoDevice() {}
-  virtual ~MockGpuVideoDevice() {}
-
-  MOCK_METHOD0(GetDevice, void*());
-  MOCK_METHOD5(CreateVideoFrameFromGlTextures,
-               bool(size_t, size_t, media::VideoFrame::Format,
-                    const std::vector<media::VideoFrame::GlTexture>&,
-                    scoped_refptr<media::VideoFrame>*));
-  MOCK_METHOD1(ReleaseVideoFrame,
-               void(const scoped_refptr<media::VideoFrame>& frame));
-  MOCK_METHOD2(ConvertToVideoFrame,
-               bool(void* buffer, scoped_refptr<media::VideoFrame> frame));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockGpuVideoDevice);
-};
-
-ACTION_P(InitializationDone, handler) {
-  media::VideoCodecInfo info;
-  info.success = true;
-  info.provides_buffers = false;
-  info.stream_info.surface_format = media::VideoFrame::RGBA;
-  info.stream_info.surface_type = media::VideoFrame::TYPE_SYSTEM_MEMORY;
-  info.stream_info.surface_width = kWidth;
-  info.stream_info.surface_height = kHeight;
-  handler->OnInitializeComplete(info);
-}
-
-ACTION_P(SendVideoFrameAllocated, handler) {
-  std::vector<media::VideoFrame::GlTexture> textures;
-  textures.push_back(kClientTexture);
-  GpuVideoDecoderMsg_VideoFrameAllocated msg(0, kFrameId, textures);
-  handler->OnMessageReceived(msg);
-}
-
-ACTION_P2(SendConsumeVideoFrame, handler, frame) {
-  media::PipelineStatistics statistics;
-  handler->ConsumeVideoFrame(frame, statistics);
-}
-
-class GpuVideoDecoderTest : public testing::Test,
-                            public IPC::Message::Sender {
- public:
-  GpuVideoDecoderTest() {
-    // Create the mock objects.
-    gles2_decoder_.reset(new gpu::gles2::MockGLES2Decoder());
-
-    gpu_video_decoder_ = new GpuVideoDecoder(
-        &message_loop_, kDecoderHostId, this, base::kNullProcessHandle,
-        gles2_decoder_.get());
-
-    // Create the mock objects.
-    mock_engine_ = new media::MockVideoDecodeEngine();
-    mock_device_ = new MockGpuVideoDevice();
-
-    // Inject the mock objects.
-    gpu_video_decoder_->SetVideoDecodeEngine(mock_engine_);
-    gpu_video_decoder_->SetGpuVideoDevice(mock_device_);
-
-    // VideoFrame for GpuVideoDevice.
-    media::VideoFrame::GlTexture textures[] = { kServiceTexture, 0, 0 };
-    media::VideoFrame::CreateFrameGlTexture(media::VideoFrame::RGBA,
-                                            kWidth, kHeight, textures,
-                                            &device_frame_);
-  }
-
-  virtual ~GpuVideoDecoderTest() {
-     gpu_video_decoder_->SetVideoDecodeEngine(NULL);
-     gpu_video_decoder_->SetGpuVideoDevice(NULL);
-  }
-
-  // This method is used to dispatch IPC messages to mock methods.
-  virtual bool Send(IPC::Message* msg) {
-    EXPECT_TRUE(msg);
-    if (!msg)
-      return false;
-
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(GpuVideoDecoderTest, *msg)
-      IPC_MESSAGE_HANDLER(GpuVideoDecoderHostMsg_InitializeACK,
-                          OnInitializeDone)
-      IPC_MESSAGE_HANDLER(GpuVideoDecoderHostMsg_DestroyACK,
-                          OnUninitializeDone)
-      IPC_MESSAGE_HANDLER(GpuVideoDecoderHostMsg_FlushACK,
-                          OnFlushDone)
-      IPC_MESSAGE_HANDLER(GpuVideoDecoderHostMsg_EmptyThisBufferACK,
-                          OnEmptyThisBufferACK)
-      IPC_MESSAGE_HANDLER(GpuVideoDecoderHostMsg_EmptyThisBufferDone,
-                          OnEmptyThisBufferDone)
-      IPC_MESSAGE_HANDLER(GpuVideoDecoderHostMsg_AllocateVideoFrames,
-                          OnAllocateVideoFrames)
-      IPC_MESSAGE_HANDLER(GpuVideoDecoderHostMsg_ReleaseAllVideoFrames,
-                          OnReleaseAllVideoFrames)
-      IPC_MESSAGE_HANDLER(GpuVideoDecoderHostMsg_ConsumeVideoFrame,
-                          OnConsumeVideoFrame)
-      IPC_MESSAGE_UNHANDLED_ERROR()
-    IPC_END_MESSAGE_MAP()
-    EXPECT_TRUE(handled);
-    delete msg;
-    return true;
-  }
-
-  // Mock methods for handling output IPC messages.
-  MOCK_METHOD1(OnInitializeDone,
-               void(const GpuVideoDecoderInitDoneParam& param));
-  MOCK_METHOD0(OnUninitializeDone, void());
-  MOCK_METHOD0(OnFlushDone, void());
-  MOCK_METHOD0(OnEmptyThisBufferDone, void());
-  MOCK_METHOD4(OnConsumeVideoFrame, void(int32 device_frame_id, int64 timestamp,
-                                         int64 duration, int32 flags));
-  MOCK_METHOD0(OnEmptyThisBufferACK, void());
-  MOCK_METHOD4(OnAllocateVideoFrames, void(int32 n, uint32 width,
-                                           uint32 height, int32 format));
-  MOCK_METHOD0(OnReleaseAllVideoFrames, void());
-
-  // Receive events from GpuVideoDecoder.
-  MOCK_METHOD0(VideoFramesAllocated, void());
-
-  void Initialize() {
-    // VideoDecodeEngine is called.
-    EXPECT_CALL(*mock_engine_, Initialize(_, _, _, _))
-        .WillOnce(InitializationDone(gpu_video_decoder_));
-
-    // Expect that initialization is completed.
-    EXPECT_CALL(*this, OnInitializeDone(_));
-
-    // Send an initialiaze message to GpuVideoDecoder.
-    GpuVideoDecoderInitParam param;
-    param.width = kWidth;
-    param.height = kHeight;
-
-    GpuVideoDecoderMsg_Initialize msg(0, param);
-    gpu_video_decoder_->OnMessageReceived(msg);
-  }
-
-  void AllocateVideoFrames() {
-    // Expect that IPC messages are sent. We'll reply with some GL textures.
-    EXPECT_CALL(*this, OnAllocateVideoFrames(
-        1, kWidth, kHeight, static_cast<int32>(media::VideoFrame::RGBA)))
-        .WillOnce(SendVideoFrameAllocated(gpu_video_decoder_));
-
-    // Expect that MakeCurrent() is called.
-    EXPECT_CALL(*gles2_decoder_.get(), MakeCurrent())
-        .WillOnce(Return(true))
-        .RetiresOnSaturation();
-
-    // Expect that translate method is called.
-    EXPECT_CALL(*gles2_decoder_.get(),
-                GetServiceTextureId(kClientTexture, NotNull()))
-        .WillOnce(DoAll(SetArgumentPointee<1>(kServiceTexture), Return(true)));
-
-    // And then GpuVideoDevice is called to create VideoFrame from GL textures.
-    EXPECT_CALL(*mock_device_,
-                CreateVideoFrameFromGlTextures(kWidth, kHeight,
-                                               media::VideoFrame::RGBA, _,
-                                               NotNull()))
-        .WillOnce(DoAll(SetArgumentPointee<4>(device_frame_), Return(true)));
-
-    // Finally the task is called.
-    EXPECT_CALL(*this, VideoFramesAllocated());
-
-    // Pretend calling GpuVideoDecoder for allocating frames.
-    gpu_video_decoder_->AllocateVideoFrames(
-        1, kWidth, kHeight, media::VideoFrame::RGBA, &decoder_frames_,
-        NewRunnableMethod(this, &GpuVideoDecoderTest::VideoFramesAllocated));
-  }
-
-  void ReleaseVideoFrames() {
-    // Expect that MakeCurrent() is called.
-    EXPECT_CALL(*gles2_decoder_.get(), MakeCurrent())
-        .WillOnce(Return(true))
-        .RetiresOnSaturation();
-
-    // Expect that video frame is released.
-    EXPECT_CALL(*mock_device_, ReleaseVideoFrame(device_frame_));
-
-    // Expect that IPC message is send to release video frame.
-    EXPECT_CALL(*this, OnReleaseAllVideoFrames());
-
-    // Call to GpuVideoDecoder to release all video frames.
-    gpu_video_decoder_->ReleaseAllVideoFrames();
-  }
-
-  void BufferExchange() {
-    // Expect that we call to produce video frame.
-    EXPECT_CALL(*mock_engine_, ProduceVideoFrame(device_frame_))
-        .WillOnce(SendConsumeVideoFrame(gpu_video_decoder_, device_frame_))
-        .RetiresOnSaturation();
-
-    // Expect that consume video frame is called.
-    EXPECT_CALL(*this, OnConsumeVideoFrame(kFrameId, 0, 0, 0))
-        .RetiresOnSaturation();
-
-    // Ask the GpuVideoDecoder to produce a video frame.
-    GpuVideoDecoderMsg_ProduceVideoFrame msg(0, kFrameId);
-    gpu_video_decoder_->OnMessageReceived(msg);
-  }
-
- private:
-  scoped_refptr<GpuVideoDecoder> gpu_video_decoder_;
-  MockGpuVideoDevice* mock_device_;
-  media::MockVideoDecodeEngine* mock_engine_;
-  scoped_ptr<gpu::gles2::MockGLES2Decoder> gles2_decoder_;
-  std::vector<scoped_refptr<media::VideoFrame> > decoder_frames_;
-  scoped_refptr<media::VideoFrame> device_frame_;
-
-  MessageLoop message_loop_;
-
-  DISALLOW_COPY_AND_ASSIGN(GpuVideoDecoderTest);
-};
-
-TEST_F(GpuVideoDecoderTest, Initialize) {
-  Initialize();
-}
-
-TEST_F(GpuVideoDecoderTest, AllocateVideoFrames) {
-  Initialize();
-  AllocateVideoFrames();
-}
-
-TEST_F(GpuVideoDecoderTest, ReleaseVideoFrames) {
-  Initialize();
-  AllocateVideoFrames();
-  ReleaseVideoFrames();
-}
-
-TEST_F(GpuVideoDecoderTest, BufferExchange) {
-  Initialize();
-  AllocateVideoFrames();
-  BufferExchange();
-  BufferExchange();
-  ReleaseVideoFrames();
-}
-
-DISABLE_RUNNABLE_METHOD_REFCOUNT(GpuVideoDecoderTest);
diff --git a/chrome/gpu/gpu_video_service.cc b/chrome/gpu/gpu_video_service.cc
deleted file mode 100644
index 008fb69..0000000
--- a/chrome/gpu/gpu_video_service.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-// 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 "chrome/gpu/gpu_channel.h"
-#include "chrome/gpu/gpu_video_decoder.h"
-#include "chrome/gpu/gpu_video_service.h"
-#include "content/common/gpu_messages.h"
-
-struct GpuVideoService::GpuVideoDecoderInfo {
-  scoped_refptr<GpuVideoDecoder> decoder;
-  GpuChannel* channel;
-};
-
-
-GpuVideoService::GpuVideoService() {
-  // TODO(jiesun): move this time consuming stuff out of here.
-  IntializeGpuVideoService();
-}
-
-GpuVideoService::~GpuVideoService() {
-  // TODO(jiesun): move this time consuming stuff out of here.
-  UnintializeGpuVideoService();
-}
-
-// static
-GpuVideoService* GpuVideoService::GetInstance() {
-  return Singleton<GpuVideoService>::get();
-}
-
-void GpuVideoService::OnChannelConnected(int32 peer_pid) {
-  LOG(ERROR) << "GpuVideoService::OnChannelConnected";
-}
-
-void GpuVideoService::OnChannelError() {
-  LOG(ERROR) << "GpuVideoService::OnChannelError";
-}
-
-bool GpuVideoService::OnMessageReceived(const IPC::Message& msg) {
-#if 0
-  IPC_BEGIN_MESSAGE_MAP(GpuVideoService, msg)
-    IPC_MESSAGE_UNHANDLED_ERROR()
-  IPC_END_MESSAGE_MAP()
-#endif
-  return false;
-}
-
-bool GpuVideoService::IntializeGpuVideoService() {
-  return true;
-}
-
-bool GpuVideoService::UnintializeGpuVideoService() {
-  return true;
-}
-
-bool GpuVideoService::CreateVideoDecoder(
-    GpuChannel* channel,
-    MessageRouter* router,
-    int32 decoder_host_id,
-    int32 decoder_id,
-    gpu::gles2::GLES2Decoder* gles2_decoder) {
-  GpuVideoDecoderInfo decoder_info;
-  decoder_info.decoder = new GpuVideoDecoder(MessageLoop::current(),
-                                             decoder_host_id,
-                                             channel,
-                                             channel->renderer_process(),
-                                             gles2_decoder);
-  decoder_info.channel = channel;
-  decoder_map_[decoder_id] = decoder_info;
-  router->AddRoute(decoder_id, decoder_info.decoder);
-
-  channel->Send(new GpuVideoDecoderHostMsg_CreateVideoDecoderDone(
-      decoder_host_id, decoder_id));
-  return true;
-}
-
-void GpuVideoService::DestroyVideoDecoder(
-    MessageRouter* router,
-    int32 decoder_id) {
-  router->RemoveRoute(decoder_id);
-  decoder_map_.erase(decoder_id);
-}
diff --git a/chrome/gpu/gpu_video_service.h b/chrome/gpu/gpu_video_service.h
deleted file mode 100644
index 371cf4b..0000000
--- a/chrome/gpu/gpu_video_service.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_GPU_VIDEO_SERVICE_H_
-#define CHROME_GPU_GPU_VIDEO_SERVICE_H_
-
-#include <map>
-
-#include "base/ref_counted.h"
-#include "base/singleton.h"
-#include "chrome/gpu/gpu_video_decoder.h"
-#include "ipc/ipc_channel.h"
-
-class GpuChannel;
-
-class GpuVideoService : public IPC::Channel::Listener {
- public:
-  static GpuVideoService* GetInstance();
-
-  // IPC::Channel::Listener.
-  virtual void OnChannelConnected(int32 peer_pid);
-  virtual void OnChannelError();
-  virtual bool OnMessageReceived(const IPC::Message& message);
-
-  // TODO(hclam): Remove return value.
-  bool CreateVideoDecoder(GpuChannel* channel,
-                          MessageRouter* router,
-                          int32 decoder_host_id,
-                          int32 decoder_id,
-                          gpu::gles2::GLES2Decoder* gles2_decoder);
-  void DestroyVideoDecoder(MessageRouter* router,
-                           int32 decoder_id);
-
- private:
-  struct GpuVideoDecoderInfo;
-
-  GpuVideoService();
-  virtual ~GpuVideoService();
-
-  std::map<int32, GpuVideoDecoderInfo> decoder_map_;
-
-  // Specialize video service on different platform will override.
-  virtual bool IntializeGpuVideoService();
-  virtual bool UnintializeGpuVideoService();
-
-  friend struct DefaultSingletonTraits<GpuVideoService>;
-  DISALLOW_COPY_AND_ASSIGN(GpuVideoService);
-};
-
-#endif  // CHROME_GPU_GPU_VIDEO_SERVICE_H_
diff --git a/chrome/gpu/gpu_watchdog_thread.cc b/chrome/gpu/gpu_watchdog_thread.cc
deleted file mode 100644
index bb01097..0000000
--- a/chrome/gpu/gpu_watchdog_thread.cc
+++ /dev/null
@@ -1,243 +0,0 @@
-// 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.
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
-#include "chrome/gpu/gpu_watchdog_thread.h"
-
-#include "base/compiler_specific.h"
-#include "build/build_config.h"
-
-namespace {
-const int64 kCheckPeriod = 2000;
-
-void DoNothing() {
-}
-}
-
-GpuWatchdogThread::GpuWatchdogThread(int timeout)
-    : base::Thread("Watchdog"),
-      watched_message_loop_(MessageLoop::current()),
-      timeout_(timeout),
-      armed_(false),
-#if defined(OS_WIN)
-      watched_thread_handle_(0),
-      arm_cpu_time_(0),
-#endif
-      ALLOW_THIS_IN_INITIALIZER_LIST(task_observer_(this)) {
-  DCHECK(timeout >= 0);
-
-#if defined(OS_WIN)
-  // GetCurrentThread returns a pseudo-handle that cannot be used by one thread
-  // to identify another. DuplicateHandle creates a "real" handle that can be
-  // used for this purpose.
-  BOOL result = DuplicateHandle(GetCurrentProcess(),
-                                GetCurrentThread(),
-                                GetCurrentProcess(),
-                                &watched_thread_handle_,
-                                THREAD_QUERY_INFORMATION,
-                                FALSE,
-                                0);
-  DCHECK(result);
-#endif
-
-  watched_message_loop_->AddTaskObserver(&task_observer_);
-}
-
-GpuWatchdogThread::~GpuWatchdogThread() {
-  // Verify that the thread was explicitly stopped. If the thread is stopped
-  // implicitly by the destructor, CleanUp() will not be called.
-  DCHECK(!method_factory_.get());
-
-#if defined(OS_WIN)
-  CloseHandle(watched_thread_handle_);
-#endif
-
-  watched_message_loop_->RemoveTaskObserver(&task_observer_);
-}
-
-void GpuWatchdogThread::PostAcknowledge() {
-  // Called on the monitored thread. Responds with OnAcknowledge. Cannot use
-  // the method factory. Rely on reference counting instead.
-  message_loop()->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(this, &GpuWatchdogThread::OnAcknowledge));
-}
-
-void GpuWatchdogThread::Init() {
-  // The method factory must be created on the watchdog thread.
-  method_factory_.reset(new MethodFactory(this));
-
-  // Schedule the first check.
-  OnCheck();
-}
-
-void GpuWatchdogThread::CleanUp() {
-  // The method factory must be destroyed on the watchdog thread.
-  method_factory_->RevokeAll();
-  method_factory_.reset();
-}
-
-GpuWatchdogThread::GpuWatchdogTaskObserver::GpuWatchdogTaskObserver(
-    GpuWatchdogThread* watchdog)
-  : watchdog_(watchdog) {
-}
-
-GpuWatchdogThread::GpuWatchdogTaskObserver::~GpuWatchdogTaskObserver() {
-}
-
-void GpuWatchdogThread::GpuWatchdogTaskObserver::WillProcessTask(
-    const Task* task)
-{
-  CheckArmed();
-}
-
-void GpuWatchdogThread::GpuWatchdogTaskObserver::DidProcessTask(
-    const Task* task)
-{
-  CheckArmed();
-}
-
-void GpuWatchdogThread::GpuWatchdogTaskObserver::CheckArmed()
-{
-  // Acknowledge the watchdog if it has armed itself. The watchdog will not
-  // change its armed state until it is acknowledged.
-  if (watchdog_->armed()) {
-    watchdog_->PostAcknowledge();
-  }
-}
-
-void GpuWatchdogThread::OnAcknowledge() {
-  // The check has already been acknowledged and another has already been
-  // scheduled by a previous call to OnAcknowledge. It is normal for a
-  // watched thread to see armed_ being true multiple times before
-  // the OnAcknowledge task is run on the watchdog thread.
-  if (!armed_)
-    return;
-
-  // Revoke any pending hang termination.
-  method_factory_->RevokeAll();
-  armed_ = false;
-
-  // The monitored thread has responded. Post a task to check it again.
-  message_loop()->PostDelayedTask(
-      FROM_HERE,
-      method_factory_->NewRunnableMethod(&GpuWatchdogThread::OnCheck),
-      kCheckPeriod);
-}
-
-#if defined(OS_WIN)
-int64 GpuWatchdogThread::GetWatchedThreadTime() {
-  FILETIME creation_time;
-  FILETIME exit_time;
-  FILETIME user_time;
-  FILETIME kernel_time;
-  BOOL result = GetThreadTimes(watched_thread_handle_,
-                               &creation_time,
-                               &exit_time,
-                               &kernel_time,
-                               &user_time);
-  DCHECK(result);
-
-  ULARGE_INTEGER user_time64;
-  user_time64.HighPart = user_time.dwHighDateTime;
-  user_time64.LowPart = user_time.dwLowDateTime;
-
-  ULARGE_INTEGER kernel_time64;
-  kernel_time64.HighPart = kernel_time.dwHighDateTime;
-  kernel_time64.LowPart = kernel_time.dwLowDateTime;
-
-  // Time is reported in units of 100 nanoseconds. Kernel and user time are
-  // summed to deal with to kinds of hangs. One is where the GPU process is
-  // stuck in user level, never calling into the kernel and kernel time is
-  // not increasing. The other is where either the kernel hangs and never
-  // returns to user level or where user level code
-  // calls into kernel level repeatedly, giving up its quanta before it is
-  // tracked, for example a loop that repeatedly Sleeps.
-  return static_cast<int64>(
-      (user_time64.QuadPart + kernel_time64.QuadPart) / 10000);
-}
-#endif
-
-void GpuWatchdogThread::OnCheck() {
-  if (armed_)
-    return;
-
-  // Must set armed before posting the task. This task might be the only task
-  // that will activate the TaskObserver on the watched thread and it must not
-  // miss the false -> true transition.
-  armed_ = true;
-
-#if defined(OS_WIN)
-  arm_cpu_time_ = GetWatchedThreadTime();
-#endif
-
-  arm_absolute_time_ = base::Time::Now();
-
-  // Post a task to the monitored thread that does nothing but wake up the
-  // TaskObserver. Any other tasks that are pending on the watched thread will
-  // also wake up the observer. This simply ensures there is at least one.
-  watched_message_loop_->PostTask(
-      FROM_HERE,
-      NewRunnableFunction(DoNothing));
-
-  // Post a task to the watchdog thread to exit if the monitored thread does
-  // not respond in time.
-  message_loop()->PostDelayedTask(
-      FROM_HERE,
-      method_factory_->NewRunnableMethod(
-          &GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang),
-      timeout_);
-}
-
-// Use the --disable-gpu-watchdog command line switch to disable this.
-void GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang() {
-#if defined(OS_WIN)
-  // Defer termination until a certain amount of CPU time has elapsed on the
-  // watched thread.
-  int64 time_since_arm = GetWatchedThreadTime() - arm_cpu_time_;
-  if (time_since_arm < timeout_) {
-    message_loop()->PostDelayedTask(
-        FROM_HERE,
-        method_factory_->NewRunnableMethod(
-            &GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang),
-        timeout_ - time_since_arm);
-    return;
-  }
-#endif
-
-  // If the watchdog woke up significantly behind schedule, disarm and reset
-  // the watchdog check. This is to prevent the watchdog thread from terminating
-  // when a machine wakes up from sleep or hibernation, which would otherwise
-  // appear to be a hang.
-  if ((base::Time::Now() - arm_absolute_time_).InMilliseconds() >
-      timeout_ * 2) {
-    armed_ = false;
-    OnCheck();
-    return;
-  }
-
-  // Make sure the timeout period is on the stack before crashing.
-  volatile int timeout = timeout_;
-
-  // For minimal developer annoyance, don't keep crashing.
-  static bool crashed = false;
-  if (crashed)
-    return;
-
-#if defined(OS_WIN)
-  if (IsDebuggerPresent())
-    return;
-#endif
-
-  LOG(ERROR) << "The GPU process hung. Terminating after "
-             << timeout_ << " ms.";
-
-  volatile int* null_pointer = NULL;
-  *null_pointer = timeout;
-
-  crashed = true;
-}
diff --git a/chrome/gpu/gpu_watchdog_thread.h b/chrome/gpu/gpu_watchdog_thread.h
deleted file mode 100644
index 2f80888..0000000
--- a/chrome/gpu/gpu_watchdog_thread.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_GPU_WATCHDOG_THREAD_H_
-#define CHROME_GPU_GPU_WATCHDOG_THREAD_H_
-
-#include "base/message_loop.h"
-#include "base/ref_counted.h"
-#include "base/scoped_ptr.h"
-#include "base/task.h"
-#include "base/threading/thread.h"
-#include "base/time.h"
-
-// A thread that intermitently sends tasks to a group of watched message loops
-// and deliberately crashes if one of them does not respond after a timeout.
-class GpuWatchdogThread : public base::Thread,
-                          public base::RefCountedThreadSafe<GpuWatchdogThread> {
- public:
-  explicit GpuWatchdogThread(int timeout);
-  virtual ~GpuWatchdogThread();
-
-  // Accessible on watched thread but only modified by watchdog thread.
-  bool armed() const { return armed_; }
-  void PostAcknowledge();
-
- protected:
-  virtual void Init();
-  virtual void CleanUp();
-
- private:
-
-  // An object of this type intercepts the reception and completion of all tasks
-  // on the watched thread and checks whether the watchdog is armed.
-  class GpuWatchdogTaskObserver : public MessageLoop::TaskObserver {
-   public:
-    explicit GpuWatchdogTaskObserver(GpuWatchdogThread* watchdog);
-    virtual ~GpuWatchdogTaskObserver();
-
-    // Implements MessageLoop::TaskObserver.
-    virtual void WillProcessTask(const Task* task);
-    virtual void DidProcessTask(const Task* task);
-
-   private:
-    void CheckArmed();
-    GpuWatchdogThread* watchdog_;
-  };
-
-  void OnAcknowledge();
-  void OnCheck();
-  void DeliberatelyCrashingToRecoverFromHang();
-  void Disable();
-
-  int64 GetWatchedThreadTime();
-
-  MessageLoop* watched_message_loop_;
-  int timeout_;
-  volatile bool armed_;
-  GpuWatchdogTaskObserver task_observer_;
-
-#if defined(OS_WIN)
-  void* watched_thread_handle_;
-  int64 arm_cpu_time_;
-#endif
-
-  base::Time arm_absolute_time_;
-
-  typedef ScopedRunnableMethodFactory<GpuWatchdogThread> MethodFactory;
-  scoped_ptr<MethodFactory> method_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(GpuWatchdogThread);
-};
-
-#endif  // CHROME_GPU_GPU_WATCHDOG_THREAD_H_
diff --git a/chrome/gpu/media/fake_gl_video_decode_engine.cc b/chrome/gpu/media/fake_gl_video_decode_engine.cc
deleted file mode 100644
index 2c68f11..0000000
--- a/chrome/gpu/media/fake_gl_video_decode_engine.cc
+++ /dev/null
@@ -1,132 +0,0 @@
-// 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 "chrome/gpu/media/fake_gl_video_decode_engine.h"
-
-#include "media/base/limits.h"
-#include "media/base/video_frame.h"
-#include "media/video/video_decode_context.h"
-
-FakeGlVideoDecodeEngine::FakeGlVideoDecodeEngine()
-    : width_(0),
-      height_(0),
-      handler_(NULL),
-      context_(NULL) {
-}
-
-FakeGlVideoDecodeEngine::~FakeGlVideoDecodeEngine() {
-}
-
-void FakeGlVideoDecodeEngine::Initialize(
-    MessageLoop* message_loop,
-    media::VideoDecodeEngine::EventHandler* event_handler,
-    media::VideoDecodeContext* context,
-    const media::VideoCodecConfig& config) {
-  handler_ = event_handler;
-  context_ = context;
-  width_ = config.width();
-  height_ = config.height();
-
-  // Create an internal VideoFrame that we can write to. This is going to be
-  // uploaded through VideoDecodeContext.
-  media::VideoFrame::CreateFrame(
-      media::VideoFrame::RGBA, width_, height_, base::TimeDelta(),
-      base::TimeDelta(), &internal_frame_);
-  memset(internal_frame_->data(media::VideoFrame::kRGBPlane), 0,
-         height_ * internal_frame_->stride(media::VideoFrame::kRGBPlane));
-
-  // Use VideoDecodeContext to allocate VideoFrame that can be consumed by
-  // external body.
-  // TODO(hclam): It is horrible to use constants everywhere in the code!
-  // The number of frames come from VideoRendererBase in the renderer, this is
-  // horrible!
-  context_->AllocateVideoFrames(
-      media::Limits::kMaxVideoFrames, width_, height_, media::VideoFrame::RGBA,
-      &external_frames_,
-      NewRunnableMethod(this,
-                        &FakeGlVideoDecodeEngine::AllocationCompleteTask));
-}
-
-void FakeGlVideoDecodeEngine::AllocationCompleteTask() {
-  DCHECK(media::Limits::kMaxVideoFrames == external_frames_.size());
-  DCHECK_EQ(media::VideoFrame::TYPE_GL_TEXTURE, external_frames_[0]->type());
-
-  media::VideoCodecInfo info;
-  info.success = true;
-  info.provides_buffers = true;
-  info.stream_info.surface_format = media::VideoFrame::RGBA;
-  info.stream_info.surface_type = media::VideoFrame::TYPE_GL_TEXTURE;
-  info.stream_info.surface_width = width_;
-  info.stream_info.surface_height = height_;
-  handler_->OnInitializeComplete(info);
-}
-
-void FakeGlVideoDecodeEngine::Uninitialize() {
-  handler_->OnUninitializeComplete();
-}
-
-void FakeGlVideoDecodeEngine::Flush() {
-  handler_->OnFlushComplete();
-}
-
-void FakeGlVideoDecodeEngine::Seek() {
-  // TODO(hclam): This is a big hack to continue playing because we need to
-  // *push* decoded frames to downstream. The model used in VideoRendererBase
-  // to wait for *push* is flawed.
-  for (size_t i = 0; i < external_frames_.size(); ++i)
-    handler_->ConsumeVideoFrame(external_frames_[i], dummy_stats_);
-  handler_->OnSeekComplete();
-}
-
-void FakeGlVideoDecodeEngine::ConsumeVideoSample(
-    scoped_refptr<media::Buffer> sample) {
-  DCHECK(!pending_frames_.empty());
-  scoped_refptr<media::VideoFrame> frame = pending_frames_.front();
-  pending_frames_.pop();
-
-  frame->SetDuration(sample->GetDuration());
-  frame->SetTimestamp(sample->GetTimestamp());
-
-  // Generate a pattern to the internal frame and then uploads it.
-  int size = width_ * height_ * 4;
-  scoped_array<uint8> buffer(new uint8[size]);
-  memset(buffer.get(), 255, size);
-
-  uint8* row = internal_frame_->data(media::VideoFrame::kRGBPlane);
-  static int seed = 0;
-
-  for (int y = 0; y < height_; ++y) {
-    int offset = y % 3;
-    for (int x = 0; x < width_; ++x) {
-      row[x * 4 + offset + 1] = seed++;
-      seed &= 255;
-    }
-    row += width_ * 4;
-  }
-  ++seed;
-
-  // After we have filled the content upload the internal frame to the
-  // VideoFrame allocated through VideoDecodeContext.
-  context_->ConvertToVideoFrame(
-      internal_frame_, frame,
-      NewRunnableMethod(this, &FakeGlVideoDecodeEngine::UploadCompleteTask,
-                        frame));
-}
-
-void FakeGlVideoDecodeEngine::ProduceVideoFrame(
-    scoped_refptr<media::VideoFrame> frame) {
-  // Enqueue the frame to the pending queue.
-  pending_frames_.push(frame);
-
-  // Fake that we need some buffer.
-  handler_->ProduceVideoSample(NULL);
-}
-
-void FakeGlVideoDecodeEngine::UploadCompleteTask(
-    scoped_refptr<media::VideoFrame> frame) {
-  // |frame| is the upload target. We can immediately send this frame out.
-  handler_->ConsumeVideoFrame(frame, dummy_stats_);
-}
-
-DISABLE_RUNNABLE_METHOD_REFCOUNT(FakeGlVideoDecodeEngine);
diff --git a/chrome/gpu/media/fake_gl_video_decode_engine.h b/chrome/gpu/media/fake_gl_video_decode_engine.h
deleted file mode 100644
index 9ffe4268..0000000
--- a/chrome/gpu/media/fake_gl_video_decode_engine.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_MEDIA_FAKE_GL_VIDEO_DECODE_ENGINE_H_
-#define CHROME_GPU_MEDIA_FAKE_GL_VIDEO_DECODE_ENGINE_H_
-
-#include <queue>
-#include <vector>
-
-#include "base/scoped_ptr.h"
-#include "media/base/pipeline.h"
-#include "media/video/video_decode_engine.h"
-
-namespace media {
-class VideoDecodeContext;
-class VideoFrame;
-}  // namespace media
-
-class FakeGlVideoDecodeEngine : public media::VideoDecodeEngine {
- public:
-  FakeGlVideoDecodeEngine();
-  virtual ~FakeGlVideoDecodeEngine();
-
-  virtual void Initialize(
-      MessageLoop* message_loop,
-      media::VideoDecodeEngine::EventHandler* event_handler,
-      media::VideoDecodeContext* context,
-      const media::VideoCodecConfig& config);
-
-  virtual void Uninitialize();
-  virtual void Flush();
-  virtual void Seek();
-  virtual void ConsumeVideoSample(scoped_refptr<media::Buffer> buffer);
-  virtual void ProduceVideoFrame(scoped_refptr<media::VideoFrame> frame);
-
- private:
-  // This method is called when video frames allocation is completed by
-  // VideoDecodeContext.
-  void AllocationCompleteTask();
-
-  // This method is called by VideoDecodeContext when uploading to a VideoFrame
-  // has completed.
-  void UploadCompleteTask(scoped_refptr<media::VideoFrame> frame);
-
-  int width_;
-  int height_;
-  media::VideoDecodeEngine::EventHandler* handler_;
-  media::VideoDecodeContext* context_;
-
-  // Internal video frame that is to be uploaded through VideoDecodeContext.
-  scoped_refptr<media::VideoFrame> internal_frame_;
-
-  // VideoFrame(s) allocated through VideoDecodeContext. These frames are
-  // opaque to us. And we need an extra upload step.
-  std::vector<scoped_refptr<media::VideoFrame> > external_frames_;
-
-  // These are the video frames that are waiting for input buffer to generate
-  // fake pattern in them.
-  std::queue<scoped_refptr<media::VideoFrame> > pending_frames_;
-
-  // Dummy statistics.
-  media::PipelineStatistics dummy_stats_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeGlVideoDecodeEngine);
-};
-
-#endif  // CHROME_GPU_MEDIA_FAKE_GL_VIDEO_DECODE_ENGINE_H_
diff --git a/chrome/gpu/media/fake_gl_video_device.cc b/chrome/gpu/media/fake_gl_video_device.cc
deleted file mode 100644
index 397b20f..0000000
--- a/chrome/gpu/media/fake_gl_video_device.cc
+++ /dev/null
@@ -1,58 +0,0 @@
-// 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 "chrome/gpu/media/fake_gl_video_device.h"
-
-#include "app/gfx/gl/gl_bindings.h"
-#include "media/base/video_frame.h"
-
-void* FakeGlVideoDevice::GetDevice() {
-  // No actual hardware device should be used.
-  return NULL;
-}
-
-bool FakeGlVideoDevice::CreateVideoFrameFromGlTextures(
-    size_t width, size_t height, media::VideoFrame::Format format,
-    const std::vector<media::VideoFrame::GlTexture>& textures,
-    scoped_refptr<media::VideoFrame>* frame) {
-  media::VideoFrame::GlTexture texture_array[media::VideoFrame::kMaxPlanes];
-  memset(texture_array, 0, sizeof(texture_array));
-
-  for (size_t i = 0; i < textures.size(); ++i) {
-    texture_array[i] = textures[i];
-  }
-
-  media::VideoFrame::CreateFrameGlTexture(format,
-                                          width,
-                                          height,
-                                          texture_array,
-                                          frame);
-  return *frame != NULL;
-}
-
-void FakeGlVideoDevice::ReleaseVideoFrame(
-    const scoped_refptr<media::VideoFrame>& frame) {
-  // We didn't need to anything here because we didin't allocate any resources
-  // for the VideoFrame(s) generated.
-}
-
-bool FakeGlVideoDevice::ConvertToVideoFrame(
-    void* buffer, scoped_refptr<media::VideoFrame> frame) {
-  // Assume we are in the right context and then upload the content to the
-  // texture.
-  glBindTexture(GL_TEXTURE_2D,
-                frame->gl_texture(media::VideoFrame::kRGBPlane));
-
-  // |buffer| is also a VideoFrame.
-  scoped_refptr<media::VideoFrame> frame_to_upload(
-      reinterpret_cast<media::VideoFrame*>(buffer));
-  DCHECK_EQ(frame->width(), frame_to_upload->width());
-  DCHECK_EQ(frame->height(), frame_to_upload->height());
-  DCHECK_EQ(frame->format(), frame_to_upload->format());
-  glTexImage2D(
-      GL_TEXTURE_2D, 0, GL_RGBA, frame_to_upload->width(),
-      frame_to_upload->height(), 0, GL_RGBA,
-      GL_UNSIGNED_BYTE, frame_to_upload->data(media::VideoFrame::kRGBPlane));
-  return true;
-}
diff --git a/chrome/gpu/media/fake_gl_video_device.h b/chrome/gpu/media/fake_gl_video_device.h
deleted file mode 100644
index 2075547..0000000
--- a/chrome/gpu/media/fake_gl_video_device.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_MEDIA_FAKE_GL_VIDEO_DEVICE_H_
-#define CHROME_GPU_MEDIA_FAKE_GL_VIDEO_DEVICE_H_
-
-#include "chrome/gpu/media/gpu_video_device.h"
-
-// A simple GpuVideoDevice that create VideoFrame with GL textures.
-// It uploads frames in RGBA format in system memory to the GL texture.
-class FakeGlVideoDevice : public GpuVideoDevice {
- public:
-  virtual ~FakeGlVideoDevice() {}
-
-  virtual void* GetDevice();
-  virtual bool CreateVideoFrameFromGlTextures(
-      size_t width, size_t height, media::VideoFrame::Format format,
-      const std::vector<media::VideoFrame::GlTexture>& textures,
-      scoped_refptr<media::VideoFrame>* frame);
-  virtual void ReleaseVideoFrame(
-      const scoped_refptr<media::VideoFrame>& frame);
-  virtual bool ConvertToVideoFrame(void* buffer,
-                                   scoped_refptr<media::VideoFrame> frame);
-};
-
-#endif  // CHROME_GPU_MEDIA_FAKE_GL_VIDEO_DEVICE_H_
diff --git a/chrome/gpu/media/gpu_video_device.h b/chrome/gpu/media/gpu_video_device.h
deleted file mode 100644
index 1ee4b6b..0000000
--- a/chrome/gpu/media/gpu_video_device.h
+++ /dev/null
@@ -1,56 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_MEDIA_GPU_VIDEO_DEVICE_H_
-#define CHROME_GPU_MEDIA_GPU_VIDEO_DEVICE_H_
-
-#include <vector>
-
-#include "media/base/video_frame.h"
-#include "media/video/video_decode_context.h"
-
-// A GpuVideoDevice is used by GpuVideoDecoder to allocate video frames
-// meaningful to a corresponding VideoDecodeEngine.
-//
-// GpuVideoDecoder will provide a set of GL textures to this class and then
-// GpuVideoDevice will transform the textures into a set of VideoFrame
-// objects that can be used by VideoDecodeEngine.
-//
-// See text in GpuVideoDecoder for the overall flow for buffer allocation.
-//
-// Since all graphics commands execute on the main thread in the GPU process
-// all the methods provided by this class are synchronous.
-class GpuVideoDevice {
- public:
-  virtual ~GpuVideoDevice() {}
-
-  // Get the hardware video decoding device handle.
-  virtual void* GetDevice() = 0;
-
-  // The following method is used by GpuVideoDecoder to create VideoFrame(s)
-  // associated with some GL textures.
-  //
-  // VideoFrame generated is used by VideoDecodeEngine for output buffer.
-  //
-  // |frame| will contain the VideoFrame generated.
-  //
-  // Return true if the operation was successful.
-  virtual bool CreateVideoFrameFromGlTextures(
-      size_t width, size_t height, media::VideoFrame::Format format,
-      const std::vector<media::VideoFrame::GlTexture>& textures,
-      scoped_refptr<media::VideoFrame>* frame) = 0;
-
-  // Release VideoFrame generated.
-  virtual void ReleaseVideoFrame(
-      const scoped_refptr<media::VideoFrame>& frame) = 0;
-
-  // Upload a device specific buffer to a VideoFrame object that can be used in
-  // the GPU process.
-  //
-  // Return true if successful.
-  virtual bool ConvertToVideoFrame(void* buffer,
-                                   scoped_refptr<media::VideoFrame> frame) = 0;
-};
-
-#endif  // CHROME_GPU_MEDIA_GPU_VIDEO_DEVICE_H_
diff --git a/chrome/gpu/media/mft_angle_video_device.cc b/chrome/gpu/media/mft_angle_video_device.cc
deleted file mode 100644
index 56cb717..0000000
--- a/chrome/gpu/media/mft_angle_video_device.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// 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 "chrome/gpu/media/mft_angle_video_device.h"
-
-#include <d3d9.h>
-
-#include "media/base/video_frame.h"
-#include "third_party/angle/src/libGLESv2/main.h"
-
-MftAngleVideoDevice::MftAngleVideoDevice()
-    : device_(reinterpret_cast<egl::Display*>(
-          eglGetCurrentDisplay())->getDevice()) {
-}
-
-void* MftAngleVideoDevice::GetDevice() {
-  return device_;
-}
-
-bool MftAngleVideoDevice::CreateVideoFrameFromGlTextures(
-    size_t width, size_t height, media::VideoFrame::Format format,
-    const std::vector<media::VideoFrame::GlTexture>& textures,
-    scoped_refptr<media::VideoFrame>* frame) {
-  media::VideoFrame::GlTexture texture_array[media::VideoFrame::kMaxPlanes];
-  memset(texture_array, 0, sizeof(texture_array));
-
-  for (size_t i = 0; i < textures.size(); ++i) {
-    texture_array[i] = textures[i];
-  }
-
-  media::VideoFrame::CreateFrameGlTexture(format,
-                                          width,
-                                          height,
-                                          texture_array,
-                                          frame);
-  return *frame != NULL;
-}
-
-void MftAngleVideoDevice::ReleaseVideoFrame(
-    const scoped_refptr<media::VideoFrame>& frame) {
-  // We didn't need to anything here because we didn't allocate any resources
-  // for the VideoFrame(s) generated.
-}
-
-bool MftAngleVideoDevice::ConvertToVideoFrame(
-    void* buffer, scoped_refptr<media::VideoFrame> frame) {
-  gl::Context* context = (gl::Context*)eglGetCurrentContext();
-  // TODO(hclam): Connect ANGLE to upload the surface to texture when changes
-  // to ANGLE is done.
-  return true;
-}
diff --git a/chrome/gpu/media/mft_angle_video_device.h b/chrome/gpu/media/mft_angle_video_device.h
deleted file mode 100644
index 0775a06..0000000
--- a/chrome/gpu/media/mft_angle_video_device.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_MEDIA_MFT_ANGLE_VIDEO_DEVICE_H_
-#define CHROME_GPU_MEDIA_MFT_ANGLE_VIDEO_DEVICE_H_
-
-#include "base/scoped_comptr_win.h"
-#include "chrome/gpu/media/gpu_video_device.h"
-
-struct IDirect3DDevice9;
-extern "C" const GUID IID_IDirect3DDevice9;
-
-namespace media {
-class VideoFrame;
-}  // namespace media
-
-// This class is used to provide hardware video device, video frames and
-// allow video frames to be uploaded to their final render target.
-//
-// This specifically serves MftH264DecodeEngine in the context of ANGLE.
-class MftAngleVideoDevice : public GpuVideoDevice {
- public:
-  MftAngleVideoDevice();
-  virtual ~MftAngleVideoDevice() {}
-
-  // GpuVideoDevice implementation.
-  virtual void* GetDevice();
-  virtual bool CreateVideoFrameFromGlTextures(
-      size_t width, size_t height, media::VideoFrame::Format format,
-      const std::vector<media::VideoFrame::GlTexture>& textures,
-      scoped_refptr<media::VideoFrame>* frame);
-  virtual void ReleaseVideoFrame(
-      const scoped_refptr<media::VideoFrame>& frame);
-  virtual bool ConvertToVideoFrame(void* buffer,
-                                   scoped_refptr<media::VideoFrame> frame);
-
- private:
-  ScopedComPtr<IDirect3DDevice9, &IID_IDirect3DDevice9> device_;
-};
-
-#endif  // CHROME_GPU_MEDIA_MFT_ANGLE_VIDEO_DEVICE_H_
diff --git a/chrome/gpu/x_util.cc b/chrome/gpu/x_util.cc
deleted file mode 100644
index 3756f67..0000000
--- a/chrome/gpu/x_util.cc
+++ /dev/null
@@ -1,11 +0,0 @@
-// 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 "chrome/gpu/x_util.h"
-
-#include <X11/Xutil.h>
-
-void ScopedPtrXFree::operator()(void* x) const {
-  ::XFree(x);
-}
diff --git a/chrome/gpu/x_util.h b/chrome/gpu/x_util.h
deleted file mode 100644
index 9b4727a..0000000
--- a/chrome/gpu/x_util.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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.
-
-#ifndef CHROME_GPU_X_UTIL_H_
-#define CHROME_GPU_X_UTIL_H_
-#pragma once
-
-// Some X-Windows specific stuff. This can be included on any platform, and will
-// be a NOP on non-Linux ones.
-
-#include "build/build_config.h"
-#include "chrome/gpu/gpu_config.h"
-
-#if defined(OS_LINUX)
-
-// Forward declares ------------------------------------------------------------
-//
-// X Windows headers do a lot of evil stuff, like "#define Status int" which
-// will cause many problems when combined with our other header files (like
-// ones that define a class local enum called "Status."
-//
-// These definitions are not Kosher, but allow us to remove this dependency and
-// actually compile X at all.
-
-typedef unsigned long XID;
-
-extern "C" {
-
-typedef struct _XDisplay Display;
-typedef struct __GLXcontextRec *GLXContext;
-
-}  // extern "C"
-
-// Utils -----------------------------------------------------------------------
-
-// scoped_ptr functor for XFree(). Use as follows:
-//   scoped_ptr_mallox<XVisualInfo, ScopedPtrXFree> foo(...);
-// where "XVisualInfo" is any X type that is freed with XFree.
-class ScopedPtrXFree {
- public:
-  void operator()(void* x) const;
-};
-
-#endif  // OS_LINUX
-
-#endif  // CHROME_GPU_X_UTIL_H_