Remove base::ScopedPtrHashMap from gpu/ipc/service/.

gpu/ipc/service/gpu_channel.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/ipc/service/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 683 matching lines @@
   return channel_->Send(message);
 }
 
 void GpuChannel::OnStreamRescheduled(int32_t stream_id, bool scheduled) {
   scoped_refptr<GpuChannelMessageQueue> queue = LookupStream(stream_id);
   DCHECK(queue);
   queue->OnRescheduled(scheduled);
 }
 
 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32_t route_id) {
-  return stubs_.get(route_id);
+  auto it = stubs_.find(route_id);
+  if (it == stubs_.end())
+    return nullptr;
+
+  return it->second.get();
 }
 
 void GpuChannel::LoseAllContexts() {
   gpu_channel_manager_->LoseAllContexts();
 }
 
 void GpuChannel::MarkAllContextsLost() {
   for (auto& kv : stubs_)
     kv.second->MarkContextLost();
 }
@@ skipping 50 matching lines @@
 
 void GpuChannel::HandleMessage(
     const scoped_refptr<GpuChannelMessageQueue>& message_queue) {
   const GpuChannelMessage* channel_msg =
       message_queue->BeginMessageProcessing();
   if (!channel_msg)
     return;
 
   const IPC::Message& msg = channel_msg->message;
   int32_t routing_id = msg.routing_id();
-  GpuCommandBufferStub* stub = stubs_.get(routing_id);
+  GpuCommandBufferStub* stub = LookupCommandBuffer(routing_id);
 
   DCHECK(!stub || stub->IsScheduled());
 
   DVLOG(1) << "received message @" << &msg << " on channel @" << this
            << " with type " << msg.type();
 
   HandleMessageHelper(msg);
 
   // If we get descheduled or yield while processing a message.
   if ((stub && stub->HasUnprocessedCommands()) ||
@@ skipping 80 matching lines @@
   DCHECK(streams_.find(stream_id) != streams_.end());
   routes_to_streams_.erase(route_id);
   streams_to_num_routes_[stream_id]--;
   filter_->RemoveRoute(route_id);
   DestroyStreamIfNecessary(streams_[stream_id]);
 }
 
 #if defined(OS_ANDROID)
 const GpuCommandBufferStub* GpuChannel::GetOneStub() const {
   for (const auto& kv : stubs_) {
-    const GpuCommandBufferStub* stub = kv.second;
+    const GpuCommandBufferStub* stub = kv.second.get();
     if (stub->decoder() && !stub->decoder()->WasContextLost())
       return stub;
   }
   return nullptr;
 }
 #endif
 
 void GpuChannel::OnCreateCommandBuffer(
     const GPUCreateCommandBufferConfig& init_params,
     int32_t route_id,
     base::SharedMemoryHandle shared_state_handle,
     bool* result,
     gpu::Capabilities* capabilities) {
   TRACE_EVENT2("gpu", "GpuChannel::OnCreateCommandBuffer", "route_id", route_id,
                "offscreen", (init_params.surface_handle == kNullSurfaceHandle));
   std::unique_ptr<base::SharedMemory> shared_state_shm(
       new base::SharedMemory(shared_state_handle, false));
   std::unique_ptr<GpuCommandBufferStub> stub =
       CreateCommandBuffer(init_params, route_id, std::move(shared_state_shm));
   if (stub) {
     *result = true;
     *capabilities = stub->decoder()->GetCapabilities();
-    stubs_.set(route_id, std::move(stub));
+    stubs_[route_id] = std::move(stub);

[Ken Russell (switch to Gerrit), 2016/12/29 05:41:15]

I confirmed that forgetting the std::move here is a compiler error, so this
looks fine.

[Avi (use Gerrit), 2016/12/29 15:18:02]

Acknowledged.

   } else {
     *result = false;
     *capabilities = gpu::Capabilities();
   }
 }
 
 std::unique_ptr<GpuCommandBufferStub> GpuChannel::CreateCommandBuffer(
     const GPUCreateCommandBufferConfig& init_params,
     int32_t route_id,
     std::unique_ptr<base::SharedMemory> shared_state_shm) {
   if (init_params.surface_handle != kNullSurfaceHandle &&
       !allow_view_command_buffers_) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): attempt to create a "
                    "view context on a non-priviledged channel";
     return nullptr;
   }
 
   int32_t share_group_id = init_params.share_group_id;
-  GpuCommandBufferStub* share_group = stubs_.get(share_group_id);
+  GpuCommandBufferStub* share_group = LookupCommandBuffer(share_group_id);
 
   if (!share_group && share_group_id != MSG_ROUTING_NONE) {
     DLOG(ERROR)
         << "GpuChannel::CreateCommandBuffer(): invalid share group id";
     return nullptr;
   }
 
   int32_t stream_id = init_params.stream_id;
   if (share_group && stream_id != share_group->stream_id()) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): stream id does not "
@@ skipping 41 matching lines @@
     return nullptr;
   }
 
   return stub;
 }
 
 void GpuChannel::OnDestroyCommandBuffer(int32_t route_id) {
   TRACE_EVENT1("gpu", "GpuChannel::OnDestroyCommandBuffer",
                "route_id", route_id);
 
-  std::unique_ptr<GpuCommandBufferStub> stub = stubs_.take_and_erase(route_id);
+  std::unique_ptr<GpuCommandBufferStub> stub;
+  auto it = stubs_.find(route_id);
+  if (it != stubs_.end()) {
+    stub = std::move(it->second);
+    stubs_.erase(it);
+  }
   // In case the renderer is currently blocked waiting for a sync reply from the
   // stub, we need to make sure to reschedule the correct stream here.
   if (stub && !stub->IsScheduled()) {
     // This stub won't get a chance to reschedule the stream so do that now.
     OnStreamRescheduled(stub->stream_id(), true);
   }
 
   RemoveRoute(route_id);
 }
 
@@ skipping 66 matching lines @@
 
       return manager->gpu_memory_buffer_factory()
           ->AsImageFactory()
           ->CreateImageForGpuMemoryBuffer(handle, size, format, internalformat,
                                           client_id_, surface_handle);
     }
   }
 }
 
 }  // namespace gpu