Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/dom_storage/dom_storage_context_wrapper.cc

 // Copyright 2013 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/browser/dom_storage/dom_storage_context_wrapper.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/filesystem/public/interfaces/directory.mojom.h"
 #include "components/leveldb/public/interfaces/leveldb.mojom.h"
 #include "components/profile_service/public/interfaces/profile.mojom.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
@@ skipping 73 matching lines @@
   void OnDirectoryOpened(filesystem::FileError err);
   void OnDatabaseOpened(leveldb::DatabaseError status);
 
   // The (possibly delayed) implementation of OpenLocalStorage(). Can be called
   // directly from that function, or through |on_database_open_callbacks_|.
   void BindLocalStorage(const url::Origin& origin,
                         mojom::LevelDBObserverPtr observer,
                         mojom::LevelDBWrapperRequest request);
 
   // Maps between an origin and its prefixed LevelDB view.
-  std::map<url::Origin, scoped_ptr<LevelDBWrapperImpl>> level_db_wrappers_;
+  std::map<url::Origin, std::unique_ptr<LevelDBWrapperImpl>> level_db_wrappers_;
 
   std::string mojo_user_id_;
   base::FilePath subdirectory_;
 
   enum ConnectionState {
     NO_CONNECTION,
     CONNECTION_IN_PROGRESS,
     CONNECTION_FINISHED
   } connection_state_;
 
-  scoped_ptr<MojoAppConnection> profile_app_connection_;
+  std::unique_ptr<MojoAppConnection> profile_app_connection_;
   profile::ProfileServicePtr profile_service_;
   filesystem::DirectoryPtr directory_;
 
   leveldb::LevelDBServicePtr leveldb_service_;
   leveldb::LevelDBDatabasePtr database_;
 
   std::vector<base::Closure> on_database_opened_callbacks_;
 
   base::WeakPtrFactory<MojoState> weak_ptr_factory_;
 };
@@ skipping 79 matching lines @@
     on_database_opened_callbacks_[i].Run();
   on_database_opened_callbacks_.clear();
 }
 
 void DOMStorageContextWrapper::MojoState::BindLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBObserverPtr observer,
     mojom::LevelDBWrapperRequest request) {
   auto found = level_db_wrappers_.find(origin);
   if (found == level_db_wrappers_.end()) {
-    level_db_wrappers_[origin] = make_scoped_ptr(new LevelDBWrapperImpl(
-        database_.get(),
-        origin.Serialize(),
+    level_db_wrappers_[origin] = base::WrapUnique(new LevelDBWrapperImpl(
+        database_.get(), origin.Serialize(),
         kPerStorageAreaQuota + kPerStorageAreaOverQuotaAllowance,
         base::Bind(&MojoState::OnLevelDDWrapperHasNoBindings,
-                   base::Unretained(this),
-                   origin)));
+                   base::Unretained(this), origin)));
     found = level_db_wrappers_.find(origin);
   }
 
   found->second->Bind(std::move(request));
   found->second->AddObserver(std::move(observer));
 }
 
 DOMStorageContextWrapper::DOMStorageContextWrapper(
     const std::string& mojo_user_id,
     const base::FilePath& profile_path,
@@ skipping 109 matching lines @@
 
 void DOMStorageContextWrapper::OpenLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBObserverPtr observer,
     mojom::LevelDBWrapperRequest request) {
   mojo_state_->OpenLocalStorage(
       origin, std::move(observer), std::move(request));
 }
 
 }  // namespace content