Remove stl_util's deletion functions from media/.

media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc

 // Copyright 2015 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 "media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/message_filter.h"
 #include "media/filters/jpeg_parser.h"
 #include "media/gpu/ipc/common/media_messages.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "media/gpu/vaapi_jpeg_decode_accelerator.h"
 #endif
 #if defined(USE_V4L2_CODEC)
 #include "media/gpu/v4l2_device.h"
 #include "media/gpu/v4l2_jpeg_decode_accelerator.h"
 #endif
 #endif
 
 namespace {
 
 void DecodeFinished(std::unique_ptr<base::SharedMemory> shm) {
   // Do nothing. Because VideoFrame is backed by |shm|, the purpose of this
-  // function is to just keep reference of |shm| to make sure it lives util
+  // function is to just keep reference of |shm| to make sure it lives until
   // decode finishes.
 }
 
 bool VerifyDecodeParams(const AcceleratedJpegDecoderMsg_Decode_Params& params) {
   const int kJpegMaxDimension = UINT16_MAX;
   if (params.coded_size.IsEmpty() ||
       params.coded_size.width() > kJpegMaxDimension ||
       params.coded_size.height() > kJpegMaxDimension) {
     LOG(ERROR) << "invalid coded_size " << params.coded_size.ToString();
     return false;
@@ skipping 98 matching lines @@
     }
     return sender_->Send(message);
   }
 
   void AddClientOnIOThread(int32_t route_id,
                            Client* client,
                            base::Callback<void(bool)> response) {
     DCHECK(io_task_runner_->BelongsToCurrentThread());
     DCHECK(client_map_.count(route_id) == 0);
 
-    client_map_[route_id] = client;
+    // See the comment on GpuJpegDecodeAccelerator::AddClient.
+    client_map_[route_id] = base::WrapUnique(client);
     response.Run(true);
   }
 
   void OnDestroyOnIOThread(const int32_t* route_id) {
     DCHECK(io_task_runner_->BelongsToCurrentThread());
     const auto& it = client_map_.find(*route_id);
     DCHECK(it != client_map_.end());
-    Client* client = it->second;
+    std::unique_ptr<Client> client = std::move(it->second);
     DCHECK(client);
     client_map_.erase(it);
 
     child_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&MessageFilter::DestroyClient, this, client));
+        FROM_HERE,
+        base::Bind(&MessageFilter::DestroyClient, this, base::Passed(&client)));
   }
 
-  void DestroyClient(Client* client) {
+  void DestroyClient(std::unique_ptr<Client> client) {
     DCHECK(child_task_runner_->BelongsToCurrentThread());
-    delete client;
     if (owner_)
       owner_->ClientRemoved();
+    // |client| is destroyed when the scope of this function is left.
   }
 
   void NotifyDecodeStatusOnIOThread(int32_t route_id,
                                     int32_t buffer_id,
                                     JpegDecodeAccelerator::Error error) {
     DCHECK(io_task_runner_->BelongsToCurrentThread());
     SendOnIOThread(new AcceleratedJpegDecoderHostMsg_DecodeAck(
         route_id, buffer_id, error));
   }
 
@@ skipping 42 matching lines @@
                  << params.input_buffer.id();
       NotifyDecodeStatusOnIOThread(*route_id, params.input_buffer.id(),
                                    JpegDecodeAccelerator::PLATFORM_FAILURE);
       base::SharedMemory::CloseHandle(params.input_buffer.handle());
       return;
     }
     frame->AddDestructionObserver(
         base::Bind(DecodeFinished, base::Passed(&output_shm)));
 
     DCHECK_GT(client_map_.count(*route_id), 0u);
-    Client* client = client_map_[*route_id];
+    Client* client = client_map_[*route_id].get();
     client->Decode(params.input_buffer, frame);
   }
 
  protected:
   ~MessageFilter() override {
     if (client_map_.empty())
       return;
 
     if (child_task_runner_->BelongsToCurrentThread()) {
-      base::STLDeleteValues(&client_map_);
+      client_map_.clear();
     } else {
       // Make sure |Client| are deleted on child thread.
       std::unique_ptr<ClientMap> client_map(new ClientMap);
       client_map->swap(client_map_);
 
       child_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&DeleteClientMapOnChildThread, base::Passed(&client_map)));
     }
   }
 
  private:
-  using ClientMap = base::hash_map<int32_t, Client*>;
+  using ClientMap = base::hash_map<int32_t, std::unique_ptr<Client>>;
 
   // Must be static because this method runs after destructor.
   static void DeleteClientMapOnChildThread(
       std::unique_ptr<ClientMap> client_map) {
-    base::STLDeleteValues(client_map.get());
+    // |client_map| is cleared when the scope of this function is left.
   }
 
   base::WeakPtr<GpuJpegDecodeAccelerator> owner_;
 
   // GPU child task runner.
   scoped_refptr<base::SingleThreadTaskRunner> child_task_runner_;
 
   // GPU IO task runner.
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
@@ skipping 58 matching lines @@
     // This should be before AddClientOnIOThread.
     channel_->AddFilter(filter_.get());
   }
   client_number_++;
 
   // In this PostTask, |client| may leak if |io_task_runner_| is destroyed
   // before |client| reached AddClientOnIOThread. However we cannot use scoper
   // to protect it because |client| can only be deleted on child thread. The IO
   // thread is destroyed at termination, at which point it's ok to leak since
   // we're going to tear down the process anyway. So we just crossed fingers
-  // here instead of making the code unnecessary complicated.
+  // here instead of making the code unnecessarily complicated.
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MessageFilter::AddClientOnIOThread, filter_,
                             route_id, client.release(), response));
 }
 
 void GpuJpegDecodeAccelerator::NotifyDecodeStatus(
     int32_t route_id,
     int32_t buffer_id,
     JpegDecodeAccelerator::Error error) {
   DCHECK(CalledOnValidThread());
@@ skipping 47 matching lines @@
   for (const auto& create_jda_function : create_jda_fps) {
     std::unique_ptr<JpegDecodeAccelerator> accelerator =
         (*create_jda_function)(base::ThreadTaskRunnerHandle::Get());
     if (accelerator && accelerator->IsSupported())
       return true;
   }
   return false;
 }
 
 }  // namespace media