Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

content/child/fileapi/file_system_dispatcher.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/child/fileapi/file_system_dispatcher.h"
 
+#include <memory>
+
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/process/process.h"
 #include "content/child/child_thread_impl.h"
 #include "content/common/fileapi/file_system_messages.h"
 #include "storage/common/fileapi/file_system_info.h"
 
 namespace content {
 
 class FileSystemDispatcher::CallbackDispatcher {
  public:
   typedef CallbackDispatcher self;
   typedef FileSystemDispatcher::StatusCallback StatusCallback;
   typedef FileSystemDispatcher::MetadataCallback MetadataCallback;
   typedef FileSystemDispatcher::ReadDirectoryCallback ReadDirectoryCallback;
   typedef FileSystemDispatcher::OpenFileSystemCallback OpenFileSystemCallback;
   typedef FileSystemDispatcher::ResolveURLCallback ResolveURLCallback;
   typedef FileSystemDispatcher::WriteCallback WriteCallback;
   typedef FileSystemDispatcher::OpenFileCallback OpenFileCallback;
 
-  static CallbackDispatcher* Create(const StatusCallback& callback) {
-    CallbackDispatcher* dispatcher = new CallbackDispatcher;
+  static std::unique_ptr<CallbackDispatcher> Create(
+      const StatusCallback& callback) {
+    std::unique_ptr<CallbackDispatcher> dispatcher =
+        base::WrapUnique(new CallbackDispatcher);
     dispatcher->status_callback_ = callback;
     dispatcher->error_callback_ = callback;
     return dispatcher;
   }
-  static CallbackDispatcher* Create(const MetadataCallback& callback,
-                                    const StatusCallback& error_callback) {
-    CallbackDispatcher* dispatcher = new CallbackDispatcher;
+  static std::unique_ptr<CallbackDispatcher> Create(
+      const MetadataCallback& callback,
+      const StatusCallback& error_callback) {
+    std::unique_ptr<CallbackDispatcher> dispatcher =
+        base::WrapUnique(new CallbackDispatcher);
     dispatcher->metadata_callback_ = callback;
     dispatcher->error_callback_ = error_callback;
     return dispatcher;
   }
-  static CallbackDispatcher* Create(const CreateSnapshotFileCallback& callback,
-                                    const StatusCallback& error_callback) {
-    CallbackDispatcher* dispatcher = new CallbackDispatcher;
+  static std::unique_ptr<CallbackDispatcher> Create(
+      const CreateSnapshotFileCallback& callback,
+      const StatusCallback& error_callback) {
+    std::unique_ptr<CallbackDispatcher> dispatcher =
+        base::WrapUnique(new CallbackDispatcher);
     dispatcher->snapshot_callback_ = callback;
     dispatcher->error_callback_ = error_callback;
     return dispatcher;
   }
-  static CallbackDispatcher* Create(const ReadDirectoryCallback& callback,
-                                    const StatusCallback& error_callback) {
-    CallbackDispatcher* dispatcher = new CallbackDispatcher;
+  static std::unique_ptr<CallbackDispatcher> Create(
+      const ReadDirectoryCallback& callback,
+      const StatusCallback& error_callback) {
+    std::unique_ptr<CallbackDispatcher> dispatcher =
+        base::WrapUnique(new CallbackDispatcher);
     dispatcher->directory_callback_ = callback;
     dispatcher->error_callback_ = error_callback;
     return dispatcher;
   }
-  static CallbackDispatcher* Create(const OpenFileSystemCallback& callback,
-                                    const StatusCallback& error_callback) {
-    CallbackDispatcher* dispatcher = new CallbackDispatcher;
+  static std::unique_ptr<CallbackDispatcher> Create(
+      const OpenFileSystemCallback& callback,
+      const StatusCallback& error_callback) {
+    std::unique_ptr<CallbackDispatcher> dispatcher =
+        base::WrapUnique(new CallbackDispatcher);
     dispatcher->filesystem_callback_ = callback;
     dispatcher->error_callback_ = error_callback;
     return dispatcher;
   }
-  static CallbackDispatcher* Create(const ResolveURLCallback& callback,
-                                    const StatusCallback& error_callback) {
-    CallbackDispatcher* dispatcher = new CallbackDispatcher;
+  static std::unique_ptr<CallbackDispatcher> Create(
+      const ResolveURLCallback& callback,
+      const StatusCallback& error_callback) {
+    std::unique_ptr<CallbackDispatcher> dispatcher =
+        base::WrapUnique(new CallbackDispatcher);
     dispatcher->resolve_callback_ = callback;
     dispatcher->error_callback_ = error_callback;
     return dispatcher;
   }
-  static CallbackDispatcher* Create(const WriteCallback& callback,
-                                    const StatusCallback& error_callback) {
-    CallbackDispatcher* dispatcher = new CallbackDispatcher;
+  static std::unique_ptr<CallbackDispatcher> Create(
+      const WriteCallback& callback,
+      const StatusCallback& error_callback) {
+    std::unique_ptr<CallbackDispatcher> dispatcher =
+        base::WrapUnique(new CallbackDispatcher);
     dispatcher->write_callback_ = callback;
     dispatcher->error_callback_ = error_callback;
     return dispatcher;
   }
 
   ~CallbackDispatcher() {}
 
   void DidSucceed() {
     status_callback_.Run(base::File::FILE_OK);
   }
@@ skipping 312 matching lines @@
                                       int64_t bytes,
                                       bool complete) {
   CallbackDispatcher* dispatcher = dispatchers_.Lookup(request_id);
   DCHECK(dispatcher);
   dispatcher->DidWrite(bytes, complete);
   if (complete)
     dispatchers_.Remove(request_id);
 }
 
 }  // namespace content