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

gpu/ipc/service/gpu_channel_manager.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_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 102 matching lines @@
   return framebuffer_completeness_cache_.get();
 }
 
 void GpuChannelManager::RemoveChannel(int client_id) {
   delegate_->DidDestroyChannel(client_id);
   gpu_channels_.erase(client_id);
 }
 
 GpuChannel* GpuChannelManager::LookupChannel(int32_t client_id) const {
   const auto& it = gpu_channels_.find(client_id);
-  return it != gpu_channels_.end() ? it->second : nullptr;
+  return it != gpu_channels_.end() ? it->second.get() : nullptr;
 }
 
 std::unique_ptr<GpuChannel> GpuChannelManager::CreateGpuChannel(
     int client_id,
     uint64_t client_tracing_id,
     bool preempts,
     bool allow_view_command_buffers,
     bool allow_real_time_streams) {
   return base::MakeUnique<GpuChannel>(
       this, sync_point_manager(), watchdog_, share_group(), mailbox_manager(),
       preempts ? preemption_flag() : nullptr,
       preempts ? nullptr : preemption_flag(), task_runner_.get(),
       io_task_runner_.get(), client_id, client_tracing_id,
       allow_view_command_buffers, allow_real_time_streams);
 }
 
 IPC::ChannelHandle GpuChannelManager::EstablishChannel(
     int client_id,
     uint64_t client_tracing_id,
     bool preempts,
     bool allow_view_command_buffers,
     bool allow_real_time_streams) {
   std::unique_ptr<GpuChannel> channel(
       CreateGpuChannel(client_id, client_tracing_id, preempts,
                        allow_view_command_buffers, allow_real_time_streams));
   IPC::ChannelHandle channel_handle = channel->Init(shutdown_event_);
-  gpu_channels_.set(client_id, std::move(channel));
+  gpu_channels_[client_id] = std::move(channel);
   return channel_handle;
 }
 
 void GpuChannelManager::InternalDestroyGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     int client_id) {
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GpuChannelManager::InternalDestroyGpuMemoryBufferOnIO,
                  base::Unretained(this), id, client_id));
@@ skipping 107 matching lines @@
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&GpuChannelManager::ScheduleWakeUpGpu,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kMaxGpuIdleTimeMs));
 }
 
 void GpuChannelManager::DoWakeUpGpu() {
   const GpuCommandBufferStub* stub = nullptr;
   for (const auto& kv : gpu_channels_) {
-    const GpuChannel* channel = kv.second;
+    const GpuChannel* channel = kv.second.get();
     stub = channel->GetOneStub();
     if (stub) {
       DCHECK(stub->decoder());
       break;
     }
   }
   if (!stub || !stub->decoder()->MakeCurrent())
     return;
   glFinish();
   DidAccessGpu();
 }
 #endif
 
 }  // namespace gpu