Refactor content/common/gpu into gpu/ipc/service

gpu/ipc/service/gpu_command_buffer_stub.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/common/gpu/gpu_command_buffer_stub.h"
+#include "gpu/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
-#include "content/common/gpu/gpu_channel.h"
-#include "content/common/gpu/gpu_channel_manager.h"
-#include "content/common/gpu/gpu_channel_manager_delegate.h"
-#include "content/common/gpu/gpu_memory_manager.h"
-#include "content/common/gpu/gpu_memory_tracking.h"
-#include "content/common/gpu/gpu_watchdog.h"
-#include "content/common/gpu/image_transport_surface.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "gpu/ipc/common/gpu_messages.h"
+#include "gpu/ipc/service/gpu_channel.h"
+#include "gpu/ipc/service/gpu_channel_manager.h"
+#include "gpu/ipc/service/gpu_channel_manager_delegate.h"
+#include "gpu/ipc/service/gpu_memory_manager.h"
+#include "gpu/ipc/service/gpu_memory_tracking.h"
+#include "gpu/ipc/service/gpu_watchdog.h"
+#include "gpu/ipc/service/image_transport_surface.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(OS_WIN)
 #include "base/win/win_util.h"
 #endif
 
 #if defined(OS_ANDROID)
-#include "content/common/gpu/stream_texture_android.h"
+#include "gpu/ipc/service/stream_texture_android.h"
 #endif
 
-namespace content {
+namespace gpu {
 struct WaitForCommandState {
   WaitForCommandState(int32_t start, int32_t end, IPC::Message* reply)
       : start(start), end(end), reply(reply) {}
 
   int32_t start;
   int32_t end;
   scoped_ptr<IPC::Message> reply;
 };
 
 namespace {
 
 // The GpuCommandBufferMemoryTracker class provides a bridge between the
 // ContextGroup's memory type managers and the GpuMemoryManager class.
-class GpuCommandBufferMemoryTracker : public gpu::gles2::MemoryTracker {
+class GpuCommandBufferMemoryTracker : public gles2::MemoryTracker {
  public:
   explicit GpuCommandBufferMemoryTracker(GpuChannel* channel,
                                          uint64_t share_group_tracing_guid)
       : tracking_group_(
             channel->gpu_channel_manager()
                 ->gpu_memory_manager()
                 ->CreateTrackingGroup(channel->GetClientPID(), this)),
         client_tracing_id_(channel->client_tracing_id()),
         client_id_(channel->client_id()),
         share_group_tracing_guid_(share_group_tracing_guid) {}
@@ skipping 70 matching lines @@
 };
 
 scoped_ptr<base::trace_event::ConvertableToTraceFormat>
 DevToolsChannelData::CreateForChannel(GpuChannel* channel) {
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue);
   res->SetInteger("renderer_pid", channel->GetClientPID());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
   return make_scoped_ptr(new DevToolsChannelData(res.release()));
 }
 
-gpu::CommandBufferId GetCommandBufferID(int channel_id, int32_t route_id) {
-  return gpu::CommandBufferId::FromUnsafeValue(
+CommandBufferId GetCommandBufferID(int channel_id, int32_t route_id) {
+  return CommandBufferId::FromUnsafeValue(
       (static_cast<uint64_t>(channel_id) << 32) | route_id);
 }
 
 }  // namespace
 
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
-    gpu::SyncPointManager* sync_point_manager,
+    SyncPointManager* sync_point_manager,
     base::SingleThreadTaskRunner* task_runner,
     GpuCommandBufferStub* share_group,
-    gpu::SurfaceHandle surface_handle,
-    gpu::gles2::MailboxManager* mailbox_manager,
-    gpu::PreemptionFlag* preempt_by_flag,
-    gpu::gles2::SubscriptionRefSet* subscription_ref_set,
-    gpu::ValueStateMap* pending_valuebuffer_state,
+    SurfaceHandle surface_handle,
+    gles2::MailboxManager* mailbox_manager,
+    PreemptionFlag* preempt_by_flag,
+    gles2::SubscriptionRefSet* subscription_ref_set,
+    ValueStateMap* pending_valuebuffer_state,
     const gfx::Size& size,
-    const gpu::gles2::DisallowedFeatures& disallowed_features,
+    const gles2::DisallowedFeatures& disallowed_features,
     const std::vector<int32_t>& attribs,
     gfx::GpuPreference gpu_preference,
     int32_t stream_id,
     int32_t route_id,
     GpuWatchdog* watchdog,
     const GURL& active_url)
     : channel_(channel),
       sync_point_manager_(sync_point_manager),
       task_runner_(task_runner),
       initialized_(false),
       surface_handle_(surface_handle),
       initial_size_(size),
       disallowed_features_(disallowed_features),
       requested_attribs_(attribs),
       gpu_preference_(gpu_preference),
       use_virtualized_gl_context_(false),
       command_buffer_id_(GetCommandBufferID(channel->client_id(), route_id)),
       stream_id_(stream_id),
       route_id_(route_id),
       last_flush_count_(0),
       surface_format_(gfx::GLSurface::SURFACE_DEFAULT),
       watchdog_(watchdog),
       waiting_for_sync_point_(false),
       previous_processed_num_(0),
       preemption_flag_(preempt_by_flag),
       active_url_(active_url) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
 
-  gpu::gles2::ContextCreationAttribHelper attrib_parser;
+  gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
     context_group_ = share_group->context_group_;
     DCHECK(context_group_->bind_generates_resource() ==
            attrib_parser.bind_generates_resource);
   } else {
-    context_group_ = new gpu::gles2::ContextGroup(
+    context_group_ = new gles2::ContextGroup(
         channel_->gpu_channel_manager()->gpu_preferences(), mailbox_manager,
         new GpuCommandBufferMemoryTracker(channel,
                                           command_buffer_id_.GetUnsafeValue()),
         channel_->gpu_channel_manager()->shader_translator_cache(),
         channel_->gpu_channel_manager()->framebuffer_completeness_cache(), NULL,
         subscription_ref_set, pending_valuebuffer_state,
         attrib_parser.bind_generates_resource);
   }
 
 // Virtualize PreferIntegratedGpu contexts by default on OS X to prevent
@@ skipping 12 matching lines @@
   use_virtualized_gl_context_ |= mailbox_manager->UsesSync();
 
 #if defined(OS_ANDROID)
   if (attrib_parser.red_size <= 5 &&
       attrib_parser.green_size <= 6 &&
       attrib_parser.blue_size <= 5 &&
       attrib_parser.alpha_size == 0)
     surface_format_ = gfx::GLSurface::SURFACE_RGB565;
   gfx::GLSurface* defaultOffscreenSurface =
       channel_->gpu_channel_manager()->GetDefaultOffscreenSurface();
-  bool is_onscreen = (surface_handle_ != gpu::kNullSurfaceHandle);
+  bool is_onscreen = (surface_handle_ != kNullSurfaceHandle);
   if (surface_format_ != defaultOffscreenSurface->GetFormat() && is_onscreen)
     use_virtualized_gl_context_ = false;
 #endif
 
-  if ((surface_handle_ == gpu::kNullSurfaceHandle) && initial_size_.IsEmpty()) {
+  if ((surface_handle_ == kNullSurfaceHandle) && initial_size_.IsEmpty()) {
     // If we're an offscreen surface with zero width and/or height, set to a
     // non-zero size so that we have a complete framebuffer for operations like
     // glClear.
     initial_size_ = gfx::Size(1, 1);
   }
 }
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 }
@@ skipping 122 matching lines @@
 
     executor_->ProcessPendingQueries();
   }
 
   ScheduleDelayedWork(
       base::TimeDelta::FromMilliseconds(kHandleMoreWorkPeriodBusyMs));
 }
 
 bool GpuCommandBufferStub::HasUnprocessedCommands() {
   if (command_buffer_) {
-    gpu::CommandBuffer::State state = command_buffer_->GetLastState();
+    CommandBuffer::State state = command_buffer_->GetLastState();
     return command_buffer_->GetPutOffset() != state.get_offset &&
-        !gpu::error::IsError(state.error);
+        !error::IsError(state.error);
   }
   return false;
 }
 
 void GpuCommandBufferStub::ScheduleDelayedWork(base::TimeDelta delay) {
   bool has_more_work = executor_.get() && (executor_->HasPendingQueries() ||
                                            executor_->HasMoreIdleWork());
   if (!has_more_work) {
     last_idle_time_ = base::TimeTicks();
     return;
@@ skipping 29 matching lines @@
   task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&GpuCommandBufferStub::PollWork, AsWeakPtr()),
       delay);
 }
 
 bool GpuCommandBufferStub::MakeCurrent() {
   if (decoder_->MakeCurrent())
     return true;
   DLOG(ERROR) << "Context lost because MakeCurrent failed.";
   command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
-  command_buffer_->SetParseError(gpu::error::kLostContext);
+  command_buffer_->SetParseError(error::kLostContext);
   CheckContextLost();
   return false;
 }
 
 void GpuCommandBufferStub::Destroy() {
   if (wait_for_token_) {
     Send(wait_for_token_->reply.release());
     wait_for_token_.reset();
   }
   if (wait_for_get_offset_) {
     Send(wait_for_get_offset_->reply.release());
     wait_for_get_offset_.reset();
   }
 
   if (initialized_) {
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
-    if ((surface_handle_ == gpu::kNullSurfaceHandle) && !active_url_.is_empty())
+    if ((surface_handle_ == kNullSurfaceHandle) && !active_url_.is_empty())
       gpu_channel_manager->delegate()->DidDestroyOffscreenContext(active_url_);
   }
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   executor_.reset();
 
@@ skipping 16 matching lines @@
 
   command_buffer_.reset();
 
   // Remove this after crbug.com/248395 is sorted out.
   surface_ = NULL;
 }
 
 void GpuCommandBufferStub::OnInitializeFailed(IPC::Message* reply_message) {
   Destroy();
   GpuCommandBufferMsg_Initialize::WriteReplyParams(
-      reply_message, false, gpu::Capabilities());
+      reply_message, false, Capabilities());
   Send(reply_message);
 }
 
 scoped_refptr<gfx::GLSurface> GpuCommandBufferStub::CreateSurface() {
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   scoped_refptr<gfx::GLSurface> surface;
-  if (surface_handle_ != gpu::kNullSurfaceHandle) {
+  if (surface_handle_ != kNullSurfaceHandle) {
     surface = ImageTransportSurface::CreateNativeSurface(
         manager, this, surface_handle_, surface_format_);
     if (!surface || !surface->Initialize(surface_format_))
       return nullptr;
   } else {
     surface = manager->GetDefaultOffscreenSurface();
   }
   return surface;
 }
 
 void GpuCommandBufferStub::OnInitialize(
     base::SharedMemoryHandle shared_state_handle,
     IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnInitialize");
   DCHECK(!command_buffer_.get());
 
   scoped_ptr<base::SharedMemory> shared_state_shm(
       new base::SharedMemory(shared_state_handle, false));
 
-  command_buffer_.reset(new gpu::CommandBufferService(
+  command_buffer_.reset(new CommandBufferService(
       context_group_->transfer_buffer_manager()));
 
   bool result = command_buffer_->Initialize();
   DCHECK(result);
 
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   DCHECK(manager);
 
-  decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group_.get()));
-  executor_.reset(new gpu::CommandExecutor(command_buffer_.get(),
+  decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
+  executor_.reset(new CommandExecutor(command_buffer_.get(),
                                            decoder_.get(), decoder_.get()));
   sync_point_client_ = sync_point_manager_->CreateSyncPointClient(
       channel_->GetSyncPointOrderData(stream_id_),
-      gpu::CommandBufferNamespace::GPU_IO, command_buffer_id_);
+      CommandBufferNamespace::GPU_IO, command_buffer_id_);
 
   if (preemption_flag_.get())
     executor_->SetPreemptByFlag(preemption_flag_);
 
   decoder_->set_engine(executor_.get());
 
   surface_ = CreateSurface();
   if (!surface_.get()) {
     DLOG(ERROR) << "Failed to create surface.";
     OnInitializeFailed(reply_message);
@@ skipping 11 matching lines @@
           gpu_preference_);
       if (!context.get()) {
         DLOG(ERROR) << "Failed to create shared context for virtualization.";
         OnInitializeFailed(reply_message);
         return;
       }
       channel_->share_group()->SetSharedContext(context.get());
     }
     // This should be a non-virtual GL context.
     DCHECK(context->GetHandle());
-    context = new gpu::GLContextVirtual(
+    context = new GLContextVirtual(
         share_group, context.get(), decoder_->AsWeakPtr());
     if (!context->Initialize(surface_.get(), gpu_preference_)) {
       // The real context created above for the default offscreen surface
       // might not be compatible with this surface.
       context = NULL;
 
       DLOG(ERROR) << "Failed to initialize virtual GL context.";
       OnInitializeFailed(reply_message);
       return;
     }
   }
   if (!context.get()) {
     context = gfx::GLContext::CreateGLContext(
         share_group, surface_.get(), gpu_preference_);
   }
   if (!context.get()) {
     DLOG(ERROR) << "Failed to create context.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (!context->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "Failed to make context current.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (!context->GetGLStateRestorer()) {
     context->SetGLStateRestorer(
-        new gpu::GLStateRestorerImpl(decoder_->AsWeakPtr()));
+        new GLStateRestorerImpl(decoder_->AsWeakPtr()));
   }
 
   if (!context_group_->has_program_cache() &&
       !context_group_->feature_info()->workarounds().disable_program_cache) {
     context_group_->set_program_cache(
         channel_->gpu_channel_manager()->program_cache());
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
-  bool offscreen = (surface_handle_ == gpu::kNullSurfaceHandle);
+  bool offscreen = (surface_handle_ == kNullSurfaceHandle);
   if (!decoder_->Initialize(surface_, context, offscreen, initial_size_,
                             disallowed_features_, requested_attribs_)) {
     DLOG(ERROR) << "Failed to initialize decoder.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (channel_->gpu_channel_manager()->
       gpu_preferences().enable_gpu_service_logging) {
     decoder_->set_log_commands(true);
   }
 
   decoder_->GetLogger()->SetMsgCallback(
       base::Bind(&GpuCommandBufferStub::SendConsoleMessage,
                  base::Unretained(this)));
   decoder_->SetShaderCacheCallback(
       base::Bind(&GpuCommandBufferStub::SendCachedShader,
                  base::Unretained(this)));
   decoder_->SetFenceSyncReleaseCallback(base::Bind(
       &GpuCommandBufferStub::OnFenceSyncRelease, base::Unretained(this)));
   decoder_->SetWaitFenceSyncCallback(base::Bind(
       &GpuCommandBufferStub::OnWaitFenceSync, base::Unretained(this)));
 
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GpuCommandBufferStub::PutChanged, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(base::Bind(
-      &gpu::CommandExecutor::SetGetBuffer, base::Unretained(executor_.get())));
+      &CommandExecutor::SetGetBuffer, base::Unretained(executor_.get())));
   command_buffer_->SetParseErrorCallback(
       base::Bind(&GpuCommandBufferStub::OnParseError, base::Unretained(this)));
   executor_->SetSchedulingChangedCallback(base::Bind(
       &GpuCommandBufferStub::OnSchedulingChanged, base::Unretained(this)));
 
   if (watchdog_) {
     executor_->SetCommandProcessedCallback(base::Bind(
         &GpuCommandBufferStub::OnCommandProcessed, base::Unretained(this)));
   }
 
-  const size_t kSharedStateSize = sizeof(gpu::CommandBufferSharedState);
+  const size_t kSharedStateSize = sizeof(CommandBufferSharedState);
   if (!shared_state_shm->Map(kSharedStateSize)) {
     DLOG(ERROR) << "Failed to map shared state buffer.";
     OnInitializeFailed(reply_message);
     return;
   }
-  command_buffer_->SetSharedStateBuffer(gpu::MakeBackingFromSharedMemory(
+  command_buffer_->SetSharedStateBuffer(MakeBackingFromSharedMemory(
       std::move(shared_state_shm), kSharedStateSize));
 
-  gpu::Capabilities capabilities = decoder_->GetCapabilities();
+  Capabilities capabilities = decoder_->GetCapabilities();
 
   GpuCommandBufferMsg_Initialize::WriteReplyParams(
       reply_message, true, capabilities);
   Send(reply_message);
 
-  if ((surface_handle_ == gpu::kNullSurfaceHandle) && !active_url_.is_empty())
+  if ((surface_handle_ == kNullSurfaceHandle) && !active_url_.is_empty())
     manager->delegate()->DidCreateOffscreenContext(active_url_);
 
   initialized_ = true;
 }
 
 void GpuCommandBufferStub::OnCreateStreamTexture(uint32_t texture_id,
                                                  int32_t stream_id,
                                                  bool* succeeded) {
 #if defined(OS_ANDROID)
   *succeeded = StreamTexture::Create(this, texture_id, stream_id);
@@ skipping 20 matching lines @@
 }
 
 void GpuCommandBufferStub::OnSetGetBuffer(int32_t shm_id,
                                           IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetGetBuffer");
   if (command_buffer_)
     command_buffer_->SetGetBuffer(shm_id);
   Send(reply_message);
 }
 
-void GpuCommandBufferStub::OnProduceFrontBuffer(const gpu::Mailbox& mailbox) {
+void GpuCommandBufferStub::OnProduceFrontBuffer(const Mailbox& mailbox) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnProduceFrontBuffer");
   if (!decoder_) {
     LOG(ERROR) << "Can't produce front buffer before initialization.";
     return;
   }
 
   decoder_->ProduceFrontBuffer(mailbox);
 }
 
 void GpuCommandBufferStub::OnParseError() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnParseError");
   DCHECK(command_buffer_.get());
-  gpu::CommandBuffer::State state = command_buffer_->GetLastState();
+  CommandBuffer::State state = command_buffer_->GetLastState();
   IPC::Message* msg = new GpuCommandBufferMsg_Destroyed(
       route_id_, state.context_lost_reason, state.error);
   msg->set_unblock(true);
   Send(msg);
 
   // Tell the browser about this context loss as well, so it can
   // determine whether client APIs like WebGL need to be immediately
   // blocked from automatically running.
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->delegate()->DidLoseContext(
-      (surface_handle_ == gpu::kNullSurfaceHandle), state.context_lost_reason,
+      (surface_handle_ == kNullSurfaceHandle), state.context_lost_reason,
       active_url_);
 
   CheckContextLost();
 }
 
 void GpuCommandBufferStub::OnSchedulingChanged(bool scheduled) {
   TRACE_EVENT1("gpu", "GpuCommandBufferStub::OnSchedulingChanged", "scheduled",
                scheduled);
   channel_->OnStreamRescheduled(stream_id_, scheduled);
 }
@@ skipping 22 matching lines @@
     LOG(ERROR)
         << "Got WaitForGetOffset command while currently waiting for offset.";
   }
   wait_for_get_offset_ =
       make_scoped_ptr(new WaitForCommandState(start, end, reply_message));
   CheckCompleteWaits();
 }
 
 void GpuCommandBufferStub::CheckCompleteWaits() {
   if (wait_for_token_ || wait_for_get_offset_) {
-    gpu::CommandBuffer::State state = command_buffer_->GetLastState();
+    CommandBuffer::State state = command_buffer_->GetLastState();
     if (wait_for_token_ &&
-        (gpu::CommandBuffer::InRange(
+        (CommandBuffer::InRange(
              wait_for_token_->start, wait_for_token_->end, state.token) ||
-         state.error != gpu::error::kNoError)) {
+         state.error != error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForTokenInRange::WriteReplyParams(
           wait_for_token_->reply.get(), state);
       Send(wait_for_token_->reply.release());
       wait_for_token_.reset();
     }
     if (wait_for_get_offset_ &&
-        (gpu::CommandBuffer::InRange(wait_for_get_offset_->start,
+        (CommandBuffer::InRange(wait_for_get_offset_->start,
                                      wait_for_get_offset_->end,
                                      state.get_offset) ||
-         state.error != gpu::error::kNoError)) {
+         state.error != error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForGetOffsetInRange::WriteReplyParams(
           wait_for_get_offset_->reply.get(), state);
       Send(wait_for_get_offset_->reply.release());
       wait_for_get_offset_.reset();
     }
   }
 }
 
 void GpuCommandBufferStub::OnAsyncFlush(
@@ skipping 10 matching lines @@
       << "Received a Flush message out-of-order";
 
   if (flush_count > last_flush_count_ &&
       ui::LatencyInfo::Verify(latency_info,
                               "GpuCommandBufferStub::OnAsyncFlush") &&
       !latency_info_callback_.is_null()) {
     latency_info_callback_.Run(latency_info);
   }
 
   last_flush_count_ = flush_count;
-  gpu::CommandBuffer::State pre_state = command_buffer_->GetLastState();
+  CommandBuffer::State pre_state = command_buffer_->GetLastState();
   command_buffer_->Flush(put_offset);
-  gpu::CommandBuffer::State post_state = command_buffer_->GetLastState();
+  CommandBuffer::State post_state = command_buffer_->GetLastState();
 
   if (pre_state.get_offset != post_state.get_offset)
     ReportState();
 
 #if defined(OS_ANDROID)
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   manager->DidAccessGpu();
 #endif
 }
 
 void GpuCommandBufferStub::OnRegisterTransferBuffer(
     int32_t id,
     base::SharedMemoryHandle transfer_buffer,
     uint32_t size) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnRegisterTransferBuffer");
 
   // Take ownership of the memory and map it into this process.
   // This validates the size.
   scoped_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(transfer_buffer, false));
   if (!shared_memory->Map(size)) {
     DVLOG(0) << "Failed to map shared memory.";
     return;
   }
 
   if (command_buffer_) {
     command_buffer_->RegisterTransferBuffer(
-        id, gpu::MakeBackingFromSharedMemory(std::move(shared_memory), size));
+        id, MakeBackingFromSharedMemory(std::move(shared_memory), size));
   }
 }
 
 void GpuCommandBufferStub::OnDestroyTransferBuffer(int32_t id) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyTransferBuffer");
 
   if (command_buffer_)
     command_buffer_->DestroyTransferBuffer(id);
 }
 
 void GpuCommandBufferStub::OnCommandProcessed() {
   if (watchdog_)
     watchdog_->CheckArmed();
 }
 
 void GpuCommandBufferStub::ReportState() { command_buffer_->UpdateState(); }
 
 void GpuCommandBufferStub::PutChanged() {
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
   executor_->PutChanged();
 }
 
 void GpuCommandBufferStub::PullTextureUpdates(
-    gpu::CommandBufferNamespace namespace_id,
-    gpu::CommandBufferId command_buffer_id,
+    CommandBufferNamespace namespace_id,
+    CommandBufferId command_buffer_id,
     uint32_t release) {
-  gpu::gles2::MailboxManager* mailbox_manager =
+  gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent()) {
-    gpu::SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
+    SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
     mailbox_manager->PullTextureUpdates(sync_token);
   }
 }
 
-void GpuCommandBufferStub::OnSignalSyncToken(const gpu::SyncToken& sync_token,
+void GpuCommandBufferStub::OnSignalSyncToken(const SyncToken& sync_token,
                                              uint32_t id) {
-  scoped_refptr<gpu::SyncPointClientState> release_state =
+  scoped_refptr<SyncPointClientState> release_state =
       sync_point_manager_->GetSyncPointClientState(
           sync_token.namespace_id(), sync_token.command_buffer_id());
 
   if (release_state) {
     sync_point_client_->Wait(release_state.get(), sync_token.release_count(),
                              base::Bind(&GpuCommandBufferStub::OnSignalAck,
                                         this->AsWeakPtr(), id));
   } else {
     OnSignalAck(id);
   }
 }
 
 void GpuCommandBufferStub::OnSignalAck(uint32_t id) {
   Send(new GpuCommandBufferMsg_SignalAck(route_id_, id));
 }
 
 void GpuCommandBufferStub::OnSignalQuery(uint32_t query_id, uint32_t id) {
   if (decoder_) {
-    gpu::gles2::QueryManager* query_manager = decoder_->GetQueryManager();
+    gles2::QueryManager* query_manager = decoder_->GetQueryManager();
     if (query_manager) {
-      gpu::gles2::QueryManager::Query* query =
+      gles2::QueryManager::Query* query =
           query_manager->GetQuery(query_id);
       if (query) {
         query->AddCallback(
           base::Bind(&GpuCommandBufferStub::OnSignalAck,
                      this->AsWeakPtr(),
                      id));
         return;
       }
     }
   }
   // Something went wrong, run callback immediately.
   OnSignalAck(id);
 }
 
 void GpuCommandBufferStub::OnFenceSyncRelease(uint64_t release) {
   if (sync_point_client_->client_state()->IsFenceSyncReleased(release)) {
     DLOG(ERROR) << "Fence Sync has already been released.";
     return;
   }
 
-  gpu::gles2::MailboxManager* mailbox_manager =
+  gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent()) {
-    gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
+    SyncToken sync_token(CommandBufferNamespace::GPU_IO, 0,
                               command_buffer_id_, release);
     mailbox_manager->PushTextureUpdates(sync_token);
   }
 
   sync_point_client_->ReleaseFenceSync(release);
 }
 
 bool GpuCommandBufferStub::OnWaitFenceSync(
-    gpu::CommandBufferNamespace namespace_id,
-    gpu::CommandBufferId command_buffer_id,
+    CommandBufferNamespace namespace_id,
+    CommandBufferId command_buffer_id,
     uint64_t release) {
   DCHECK(!waiting_for_sync_point_);
   DCHECK(executor_->scheduled());
 
-  scoped_refptr<gpu::SyncPointClientState> release_state =
+  scoped_refptr<SyncPointClientState> release_state =
       sync_point_manager_->GetSyncPointClientState(namespace_id,
                                                    command_buffer_id);
 
   if (!release_state)
     return true;
 
   if (release_state->IsFenceSyncReleased(release)) {
     PullTextureUpdates(namespace_id, command_buffer_id, release);
     return true;
   }
 
   TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
                            this);
   waiting_for_sync_point_ = true;
   sync_point_client_->WaitNonThreadSafe(
       release_state.get(), release, task_runner_,
       base::Bind(&GpuCommandBufferStub::OnWaitFenceSyncCompleted,
                  this->AsWeakPtr(), namespace_id, command_buffer_id, release));
 
   if (!waiting_for_sync_point_)
     return true;
 
   executor_->SetScheduled(false);
   return false;
 }
 
 void GpuCommandBufferStub::OnWaitFenceSyncCompleted(
-    gpu::CommandBufferNamespace namespace_id,
-    gpu::CommandBufferId command_buffer_id,
+    CommandBufferNamespace namespace_id,
+    CommandBufferId command_buffer_id,
     uint64_t release) {
   DCHECK(waiting_for_sync_point_);
   TRACE_EVENT_ASYNC_END1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
                          this);
   PullTextureUpdates(namespace_id, command_buffer_id, release);
   waiting_for_sync_point_ = false;
   executor_->SetScheduled(true);
 }
 
 void GpuCommandBufferStub::OnCreateImage(
     const GpuCommandBufferMsg_CreateImage_Params& params) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateImage");
   const int32_t id = params.id;
   const gfx::GpuMemoryBufferHandle& handle = params.gpu_memory_buffer;
   const gfx::Size& size = params.size;
   const gfx::BufferFormat& format = params.format;
   const uint32_t internalformat = params.internal_format;
   const uint64_t image_release_count = params.image_release_count;
 
   if (!decoder_)
     return;
 
-  gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
+  gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image already exists with same ID.";
     return;
   }
 
   if (!gpu::IsGpuMemoryBufferFormatSupported(format,
                                              decoder_->GetCapabilities())) {
     LOG(ERROR) << "Format is not supported.";
     return;
@@ skipping 20 matching lines @@
     sync_point_client_->ReleaseFenceSync(image_release_count);
   }
 }
 
 void GpuCommandBufferStub::OnDestroyImage(int32_t id) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyImage");
 
   if (!decoder_)
     return;
 
-  gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
+  gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (!image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image with ID doesn't exist.";
     return;
   }
 
   image_manager->RemoveImage(id);
 }
 
 void GpuCommandBufferStub::SendConsoleMessage(int32_t id,
@@ skipping 15 matching lines @@
 void GpuCommandBufferStub::AddDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.AddObserver(observer);
 }
 
 void GpuCommandBufferStub::RemoveDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.RemoveObserver(observer);
 }
 
-const gpu::gles2::FeatureInfo* GpuCommandBufferStub::GetFeatureInfo() const {
+const gles2::FeatureInfo* GpuCommandBufferStub::GetFeatureInfo() const {
   return context_group_->feature_info();
 }
 
-gpu::gles2::MemoryTracker* GpuCommandBufferStub::GetMemoryTracker() const {
+gles2::MemoryTracker* GpuCommandBufferStub::GetMemoryTracker() const {
   return context_group_->memory_tracker();
 }
 
 bool GpuCommandBufferStub::CheckContextLost() {
   DCHECK(command_buffer_);
-  gpu::CommandBuffer::State state = command_buffer_->GetLastState();
-  bool was_lost = state.error == gpu::error::kLostContext;
+  CommandBuffer::State state = command_buffer_->GetLastState();
+  bool was_lost = state.error == error::kLostContext;
 
   if (was_lost) {
     bool was_lost_by_robustness =
         decoder_ && decoder_->WasContextLostByRobustnessExtension();
 
     // Work around issues with recovery by allowing a new GPU process to launch.
     if ((was_lost_by_robustness ||
          context_group_->feature_info()->workarounds().exit_on_context_lost) &&
         !channel_->gpu_channel_manager()->gpu_preferences().single_process &&
         !channel_->gpu_channel_manager()->gpu_preferences().in_process_gpu) {
@@ skipping 12 matching lines @@
       channel_->LoseAllContexts();
     }
   }
 
   CheckCompleteWaits();
   return was_lost;
 }
 
 void GpuCommandBufferStub::MarkContextLost() {
   if (!command_buffer_ ||
-      command_buffer_->GetLastState().error == gpu::error::kLostContext)
+      command_buffer_->GetLastState().error == error::kLostContext)
     return;
 
-  command_buffer_->SetContextLostReason(gpu::error::kUnknown);
+  command_buffer_->SetContextLostReason(error::kUnknown);
   if (decoder_)
-    decoder_->MarkContextLost(gpu::error::kUnknown);
-  command_buffer_->SetParseError(gpu::error::kLostContext);
+    decoder_->MarkContextLost(error::kUnknown);
+  command_buffer_->SetParseError(error::kLostContext);
 }
 
 void GpuCommandBufferStub::SendSwapBuffersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info,
     gfx::SwapResult result) {
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, latency_info,
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
-}  // namespace content
+}  // namespace gpu