BASELINE: Update Chromium to 55.0.2883.105

And updates ninja to 1.7.2

Change-Id: I20d43c737f82764d857ada9a55586901b18b9243
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

42 files changed, 231 insertions, 549 deletions

diff --git a/chromium/storage/browser/BUILD.gn b/chromium/storage/browser/BUILD.gn
index 4a712dc7391..a4cc79a2e3f 100644
--- a/chromium/storage/browser/BUILD.gn
+++ b/chromium/storage/browser/BUILD.gn
@@ -2,7 +2,6 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-# GYP version: storage/storage_browser.gyp:storage
 component("browser") {
   output_name = "storage_browser"
   sources = [
diff --git a/chromium/storage/browser/blob/blob_async_builder_host.cc b/chromium/storage/browser/blob/blob_async_builder_host.cc
index c30b3833e90..a73d9d68323 100644
--- a/chromium/storage/browser/blob/blob_async_builder_host.cc
+++ b/chromium/storage/browser/blob/blob_async_builder_host.cc
@@ -108,8 +108,8 @@ BlobTransportResult BlobAsyncBuilderHost::RegisterBlobUUID(
     }
     handles.emplace_back(std::move(handle));
   }
-  async_blob_map_[uuid] = base::WrapUnique(
-      new BlobBuildingState(uuid, referenced_blob_uuids, &handles));
+  async_blob_map_[uuid] = base::MakeUnique<BlobBuildingState>(
+      uuid, referenced_blob_uuids, &handles);
   return BlobTransportResult::DONE;
 }
 
@@ -404,7 +404,7 @@ BlobTransportResult BlobAsyncBuilderHost::ContinueBlobMemoryRequests(
 
   state->request_memory_callback.Run(
       std::move(byte_requests), std::move(shared_memory),
-      base::WrapUnique(new std::vector<base::File>()));
+      base::MakeUnique<std::vector<base::File>>());
   return BlobTransportResult::PENDING_RESPONSES;
 }
 
diff --git a/chromium/storage/browser/blob/blob_reader.cc b/chromium/storage/browser/blob/blob_reader.cc
index b342fc907c5..2afb964e88a 100644
--- a/chromium/storage/browser/blob/blob_reader.cc
+++ b/chromium/storage/browser/blob/blob_reader.cc
@@ -15,7 +15,6 @@
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/sequenced_task_runner.h"
-#include "base/stl_util.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/io_buffer.h"
@@ -76,7 +75,6 @@ BlobReader::BlobReader(
 }
 
 BlobReader::~BlobReader() {
-  STLDeleteValues(&index_to_reader_);
 }
 
 BlobReader::Status BlobReader::CalculateSize(
@@ -620,13 +618,13 @@ FileStreamReader* BlobReader::GetOrCreateFileReaderAtIndex(size_t index) {
   auto it = index_to_reader_.find(index);
   if (it != index_to_reader_.end()) {
     DCHECK(it->second);
-    return it->second;
+    return it->second.get();
   }
   std::unique_ptr<FileStreamReader> reader = CreateFileStreamReader(item, 0);
   FileStreamReader* ret_value = reader.get();
   if (!ret_value)
     return nullptr;
-  index_to_reader_[index] = reader.release();
+  index_to_reader_[index] = std::move(reader);
   return ret_value;
 }
 
@@ -662,19 +660,10 @@ std::unique_ptr<FileStreamReader> BlobReader::CreateFileStreamReader(
 void BlobReader::SetFileReaderAtIndex(
     size_t index,
     std::unique_ptr<FileStreamReader> reader) {
-  auto found = index_to_reader_.find(current_item_index_);
-  if (found != index_to_reader_.end()) {
-    if (found->second) {
-      delete found->second;
-    }
-    if (!reader.get()) {
-      index_to_reader_.erase(found);
-      return;
-    }
-    found->second = reader.release();
-  } else if (reader.get()) {
-    index_to_reader_[current_item_index_] = reader.release();
-  }
+  if (reader)
+    index_to_reader_[index] = std::move(reader);
+  else
+    index_to_reader_.erase(index);
 }
 
 }  // namespace storage
diff --git a/chromium/storage/browser/blob/blob_reader.h b/chromium/storage/browser/blob/blob_reader.h
index 0a5a4b44c82..5a58f8aa255 100644
--- a/chromium/storage/browser/blob/blob_reader.h
+++ b/chromium/storage/browser/blob/blob_reader.h
@@ -214,7 +214,7 @@ class STORAGE_EXPORT BlobReader {
   uint64_t total_size_ = 0;
   uint64_t remaining_bytes_ = 0;
   size_t pending_get_file_info_count_ = 0;
-  std::map<size_t, FileStreamReader*> index_to_reader_;
+  std::map<size_t, std::unique_ptr<FileStreamReader>> index_to_reader_;
   size_t current_item_index_ = 0;
   uint64_t current_item_offset_ = 0;
 
diff --git a/chromium/storage/browser/blob/blob_storage_registry.cc b/chromium/storage/browser/blob/blob_storage_registry.cc
index a0f03b25fd4..9ddcb99b555 100644
--- a/chromium/storage/browser/blob/blob_storage_registry.cc
+++ b/chromium/storage/browser/blob/blob_storage_registry.cc
@@ -63,7 +63,7 @@ BlobStorageRegistry::Entry* BlobStorageRegistry::CreateEntry(
     const std::string& uuid,
     const std::string& content_type,
     const std::string& content_disposition) {
-  DCHECK(!ContainsKey(blob_map_, uuid));
+  DCHECK(!base::ContainsKey(blob_map_, uuid));
   std::unique_ptr<Entry> entry(new Entry(1, BlobState::PENDING));
   entry->content_type = content_type;
   entry->content_disposition = content_disposition;
@@ -115,7 +115,7 @@ bool BlobStorageRegistry::DeleteURLMapping(const GURL& blob_url,
 }
 
 bool BlobStorageRegistry::IsURLMapped(const GURL& blob_url) const {
-  return ContainsKey(url_to_uuid_, blob_url);
+  return base::ContainsKey(url_to_uuid_, blob_url);
 }
 
 BlobStorageRegistry::Entry* BlobStorageRegistry::GetEntryFromURL(
diff --git a/chromium/storage/browser/blob/blob_url_request_job.cc b/chromium/storage/browser/blob/blob_url_request_job.cc
index 24882d5e2c9..759f323c637 100644
--- a/chromium/storage/browser/blob/blob_url_request_job.cc
+++ b/chromium/storage/browser/blob/blob_url_request_job.cc
@@ -261,10 +261,16 @@ void BlobURLRequestJob::NotifyFailure(int error_code) {
     case net::ERR_REQUEST_RANGE_NOT_SATISFIABLE:
       status_code = net::HTTP_REQUESTED_RANGE_NOT_SATISFIABLE;
       break;
+    case net::ERR_INVALID_ARGUMENT:
+      status_code = net::HTTP_BAD_REQUEST;
+      break;
+    case net::ERR_CACHE_READ_FAILURE:
+    case net::ERR_CACHE_CHECKSUM_READ_FAILURE:
+    case net::ERR_UNEXPECTED:
     case net::ERR_FAILED:
       break;
     default:
-      DCHECK(false);
+      DCHECK(false) << "Error code not supported: " << error_code;
       break;
   }
   HeadersCompleted(status_code);
diff --git a/chromium/storage/browser/blob/scoped_file.h b/chromium/storage/browser/blob/scoped_file.h
index da834740ac5..890ccdbfa3f 100644
--- a/chromium/storage/browser/blob/scoped_file.h
+++ b/chromium/storage/browser/blob/scoped_file.h
@@ -21,8 +21,7 @@ namespace storage {
 
 // A scoped reference for a FilePath that can optionally schedule the file
 // to be deleted and/or to notify a consumer when it is going to be scoped out.
-// This class supports move semantics, i.e. consumers can call Pass() to
-// pass the ownership of ScopedFile.
+// Consumers can pass the ownership of a ScopedFile via std::move().
 //
 // TODO(kinuko): Probably this can be moved under base or somewhere more
 // common place.
diff --git a/chromium/storage/browser/fileapi/copy_or_move_operation_delegate.cc b/chromium/storage/browser/fileapi/copy_or_move_operation_delegate.cc
index ca5b409e127..d8b72157ca0 100644
--- a/chromium/storage/browser/fileapi/copy_or_move_operation_delegate.cc
+++ b/chromium/storage/browser/fileapi/copy_or_move_operation_delegate.cc
@@ -13,6 +13,7 @@
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/blob/shareable_file_reference.h"
@@ -754,7 +755,6 @@ CopyOrMoveOperationDelegate::CopyOrMoveOperationDelegate(
 }
 
 CopyOrMoveOperationDelegate::~CopyOrMoveOperationDelegate() {
-  STLDeleteElements(&running_copy_set_);
 }
 
 void CopyOrMoveOperationDelegate::Run() {
@@ -795,13 +795,13 @@ void CopyOrMoveOperationDelegate::ProcessFile(
   }
 
   FileSystemURL dest_url = CreateDestURL(src_url);
-  CopyOrMoveImpl* impl = NULL;
+  std::unique_ptr<CopyOrMoveImpl> impl;
   if (same_file_system_ &&
       (file_system_context()
            ->GetFileSystemBackend(src_url.type())
            ->HasInplaceCopyImplementation(src_url.type()) ||
        operation_type_ == OPERATION_MOVE)) {
-    impl = new CopyOrMoveOnSameFileSystemImpl(
+    impl = base::MakeUnique<CopyOrMoveOnSameFileSystemImpl>(
         operation_runner(), operation_type_, src_url, dest_url, option_,
         base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
                    weak_factory_.GetWeakPtr(), src_url));
@@ -827,7 +827,7 @@ void CopyOrMoveOperationDelegate::ProcessFile(
       std::unique_ptr<FileStreamWriter> writer =
           file_system_context()->CreateFileStreamWriter(dest_url, 0);
       if (reader && writer) {
-        impl = new StreamCopyOrMoveImpl(
+        impl = base::MakeUnique<StreamCopyOrMoveImpl>(
             operation_runner(), file_system_context(), operation_type_, src_url,
             dest_url, option_, std::move(reader), std::move(writer),
             base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
@@ -836,7 +836,7 @@ void CopyOrMoveOperationDelegate::ProcessFile(
     }
 
     if (!impl) {
-      impl = new SnapshotCopyOrMoveImpl(
+      impl = base::MakeUnique<SnapshotCopyOrMoveImpl>(
           operation_runner(), operation_type_, src_url, dest_url, option_,
           validator_factory,
           base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
@@ -845,10 +845,12 @@ void CopyOrMoveOperationDelegate::ProcessFile(
   }
 
   // Register the running task.
-  running_copy_set_.insert(impl);
-  impl->Run(base::Bind(
-      &CopyOrMoveOperationDelegate::DidCopyOrMoveFile,
-      weak_factory_.GetWeakPtr(), src_url, dest_url, callback, impl));
+
+  CopyOrMoveImpl* impl_ptr = impl.get();
+  running_copy_set_[impl_ptr] = std::move(impl);
+  impl_ptr->Run(base::Bind(&CopyOrMoveOperationDelegate::DidCopyOrMoveFile,
+                           weak_factory_.GetWeakPtr(), src_url, dest_url,
+                           callback, impl_ptr));
 }
 
 void CopyOrMoveOperationDelegate::ProcessDirectory(
@@ -893,9 +895,8 @@ void CopyOrMoveOperationDelegate::PostProcessDirectory(
 
 void CopyOrMoveOperationDelegate::OnCancel() {
   // Request to cancel all running Copy/Move file.
-  for (std::set<CopyOrMoveImpl*>::iterator iter = running_copy_set_.begin();
-       iter != running_copy_set_.end(); ++iter)
-    (*iter)->Cancel();
+  for (auto& job : running_copy_set_)
+    job.first->Cancel();
 }
 
 void CopyOrMoveOperationDelegate::DidCopyOrMoveFile(
@@ -905,7 +906,6 @@ void CopyOrMoveOperationDelegate::DidCopyOrMoveFile(
     CopyOrMoveImpl* impl,
     base::File::Error error) {
   running_copy_set_.erase(impl);
-  delete impl;
 
   if (!progress_callback_.is_null() && error != base::File::FILE_OK &&
       error != base::File::FILE_ERROR_NOT_A_FILE)
diff --git a/chromium/storage/browser/fileapi/copy_or_move_operation_delegate.h b/chromium/storage/browser/fileapi/copy_or_move_operation_delegate.h
index a853b781124..9d5bd243a93 100644
--- a/chromium/storage/browser/fileapi/copy_or_move_operation_delegate.h
+++ b/chromium/storage/browser/fileapi/copy_or_move_operation_delegate.h
@@ -7,8 +7,8 @@
 
 #include <stdint.h>
 
+#include <map>
 #include <memory>
-#include <set>
 #include <stack>
 
 #include "base/macros.h"
@@ -156,7 +156,7 @@ class CopyOrMoveOperationDelegate
   CopyProgressCallback progress_callback_;
   StatusCallback callback_;
 
-  std::set<CopyOrMoveImpl*> running_copy_set_;
+  std::map<CopyOrMoveImpl*, std::unique_ptr<CopyOrMoveImpl>> running_copy_set_;
   base::WeakPtrFactory<CopyOrMoveOperationDelegate> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CopyOrMoveOperationDelegate);
diff --git a/chromium/storage/browser/fileapi/external_mount_points.cc b/chromium/storage/browser/fileapi/external_mount_points.cc
index f9ffdbdbb99..05eb0233a6d 100644
--- a/chromium/storage/browser/fileapi/external_mount_points.cc
+++ b/chromium/storage/browser/fileapi/external_mount_points.cc
@@ -7,7 +7,7 @@
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "storage/browser/fileapi/file_system_url.h"
 
 namespace {
@@ -103,7 +103,8 @@ bool ExternalMountPoints::RegisterFileSystem(
   if (!ValidateNewMountPoint(mount_name, type, path))
     return false;
 
-  instance_map_[mount_name] = new Instance(type, path, mount_option);
+  instance_map_[mount_name] =
+      base::MakeUnique<Instance>(type, path, mount_option);
   if (!path.empty() && IsOverlappingMountPathForbidden(type))
     path_to_name_map_.insert(std::make_pair(path, mount_name));
   return true;
@@ -117,13 +118,12 @@ bool ExternalMountPoints::HandlesFileSystemMountType(
 
 bool ExternalMountPoints::RevokeFileSystem(const std::string& mount_name) {
   base::AutoLock locker(lock_);
-  NameToInstance::iterator found = instance_map_.find(mount_name);
+  auto found = instance_map_.find(mount_name);
   if (found == instance_map_.end())
     return false;
-  Instance* instance = found->second;
+  Instance* instance = found->second.get();
   if (IsOverlappingMountPathForbidden(instance->type()))
     path_to_name_map_.erase(NormalizeFilePath(instance->path()));
-  delete found->second;
   instance_map_.erase(found);
   return true;
 }
@@ -132,7 +132,7 @@ bool ExternalMountPoints::GetRegisteredPath(
     const std::string& filesystem_id, base::FilePath* path) const {
   DCHECK(path);
   base::AutoLock locker(lock_);
-  NameToInstance::const_iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end())
     return false;
   *path = found->second->path();
@@ -167,13 +167,12 @@ bool ExternalMountPoints::CrackVirtualPath(
   base::FilePath cracked_path;
   {
     base::AutoLock locker(lock_);
-    NameToInstance::const_iterator found_instance =
-        instance_map_.find(maybe_mount_name);
+    auto found_instance = instance_map_.find(maybe_mount_name);
     if (found_instance == instance_map_.end())
       return false;
 
     *mount_name = maybe_mount_name;
-    const Instance* instance = found_instance->second;
+    const Instance* instance = found_instance->second.get();
     if (type)
       *type = instance->type();
     cracked_path = instance->path();
@@ -204,9 +203,8 @@ void ExternalMountPoints::AddMountPointInfosTo(
     std::vector<MountPointInfo>* mount_points) const {
   base::AutoLock locker(lock_);
   DCHECK(mount_points);
-  for (NameToInstance::const_iterator iter = instance_map_.begin();
-       iter != instance_map_.end(); ++iter) {
-    mount_points->push_back(MountPointInfo(iter->first, iter->second->path()));
+  for (const auto& pair : instance_map_) {
+    mount_points->push_back(MountPointInfo(pair.first, pair.second->path()));
   }
 }
 
@@ -249,20 +247,16 @@ void ExternalMountPoints::RevokeAllFileSystems() {
   NameToInstance instance_map_copy;
   {
     base::AutoLock locker(lock_);
-    instance_map_copy = instance_map_;
-    instance_map_.clear();
+    // This swap moves the contents of instance_map_ to the local variable so
+    // they can be freed outside the lock.
+    instance_map_copy.swap(instance_map_);
     path_to_name_map_.clear();
   }
-  STLDeleteContainerPairSecondPointers(instance_map_copy.begin(),
-                                       instance_map_copy.end());
 }
 
-ExternalMountPoints::ExternalMountPoints() {}
+ExternalMountPoints::ExternalMountPoints() = default;
 
-ExternalMountPoints::~ExternalMountPoints() {
-  STLDeleteContainerPairSecondPointers(instance_map_.begin(),
-                                       instance_map_.end());
-}
+ExternalMountPoints::~ExternalMountPoints() = default;
 
 FileSystemURL ExternalMountPoints::CrackFileSystemURL(
     const FileSystemURL& url) const {
@@ -312,7 +306,7 @@ bool ExternalMountPoints::ValidateNewMountPoint(const std::string& mount_name,
     return false;
 
   // Verify there is no registered mount point with the same name.
-  NameToInstance::iterator found = instance_map_.find(mount_name);
+  auto found = instance_map_.find(mount_name);
   if (found != instance_map_.end())
     return false;
 
diff --git a/chromium/storage/browser/fileapi/external_mount_points.h b/chromium/storage/browser/fileapi/external_mount_points.h
index af853d73a97..36f5ebd5ed2 100644
--- a/chromium/storage/browser/fileapi/external_mount_points.h
+++ b/chromium/storage/browser/fileapi/external_mount_points.h
@@ -6,6 +6,7 @@
 #define STORAGE_BROWSER_FILEAPI_EXTERNAL_MOUNT_POINTS_H_
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -119,7 +120,7 @@ class STORAGE_EXPORT ExternalMountPoints
   // Represents each file system instance (defined in the .cc).
   class Instance;
 
-  typedef std::map<std::string, Instance*> NameToInstance;
+  typedef std::map<std::string, std::unique_ptr<Instance>> NameToInstance;
 
   // Reverse map from registered path to its corresponding mount name.
   typedef std::map<base::FilePath, std::string> PathToName;
diff --git a/chromium/storage/browser/fileapi/file_system_context.cc b/chromium/storage/browser/fileapi/file_system_context.cc
index c689d174fc9..9c1de0ba4e9 100644
--- a/chromium/storage/browser/fileapi/file_system_context.cc
+++ b/chromium/storage/browser/fileapi/file_system_context.cc
@@ -183,8 +183,8 @@ FileSystemContext::FileSystemContext(
   // Chrome OS the additional backend chromeos::FileSystemBackend handles these
   // types.
   isolated_backend_.reset(new IsolatedFileSystemBackend(
-      !ContainsKey(backend_map_, kFileSystemTypeNativeLocal),
-      !ContainsKey(backend_map_, kFileSystemTypeNativeForPlatformApp)));
+      !base::ContainsKey(backend_map_, kFileSystemTypeNativeLocal),
+      !base::ContainsKey(backend_map_, kFileSystemTypeNativeForPlatformApp)));
   RegisterBackend(isolated_backend_.get());
 
   if (quota_manager_proxy) {
diff --git a/chromium/storage/browser/fileapi/file_system_operation.h b/chromium/storage/browser/fileapi/file_system_operation.h
index 8f11c1e2a71..3e0c49a4aed 100644
--- a/chromium/storage/browser/fileapi/file_system_operation.h
+++ b/chromium/storage/browser/fileapi/file_system_operation.h
@@ -297,6 +297,8 @@ class FileSystemOperation {
   //   CopyInForeignFile and CreateDirectory on dest filesystem
   //   for cross-filesystem case.
   //
+  // TODO(crbug.com/171284): Restore directory timestamps after the Move
+  //                         operation.
   virtual void Move(const FileSystemURL& src_path,
                     const FileSystemURL& dest_path,
                     CopyOrMoveOption option,
diff --git a/chromium/storage/browser/fileapi/file_system_operation_runner.cc b/chromium/storage/browser/fileapi/file_system_operation_runner.cc
index a3612595fe4..cc6bd3838ff 100644
--- a/chromium/storage/browser/fileapi/file_system_operation_runner.cc
+++ b/chromium/storage/browser/fileapi/file_system_operation_runner.cc
@@ -306,8 +306,8 @@ OperationID FileSystemOperationRunner::Truncate(
 void FileSystemOperationRunner::Cancel(
     OperationID id,
     const StatusCallback& callback) {
-  if (ContainsKey(finished_operations_, id)) {
-    DCHECK(!ContainsKey(stray_cancel_callbacks_, id));
+  if (base::ContainsKey(finished_operations_, id)) {
+    DCHECK(!base::ContainsKey(stray_cancel_callbacks_, id));
     stray_cancel_callbacks_[id] = callback;
     return;
   }
diff --git a/chromium/storage/browser/fileapi/file_system_url_request_job_factory.cc b/chromium/storage/browser/fileapi/file_system_url_request_job_factory.cc
index 90dd81fad82..f2481b5a896 100644
--- a/chromium/storage/browser/fileapi/file_system_url_request_job_factory.cc
+++ b/chromium/storage/browser/fileapi/file_system_url_request_job_factory.cc
@@ -52,7 +52,7 @@ net::URLRequestJob* FileSystemProtocolHandler::MaybeCreateJob(
   // If the path ends with a /, we know it's a directory. If the path refers
   // to a directory and gets dispatched to FileSystemURLRequestJob, that class
   // redirects back here, by adding a / to the URL.
-  if (!path.empty() && path[path.size() - 1] == '/') {
+  if (!path.empty() && path.back() == '/') {
     return new FileSystemDirURLRequestJob(
         request, network_delegate, storage_domain_, file_system_context_);
   }
diff --git a/chromium/storage/browser/fileapi/file_system_usage_cache.cc b/chromium/storage/browser/fileapi/file_system_usage_cache.cc
index 8b6ec2236ce..c96021e9fab 100644
--- a/chromium/storage/browser/fileapi/file_system_usage_cache.cc
+++ b/chromium/storage/browser/fileapi/file_system_usage_cache.cc
@@ -11,6 +11,7 @@
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/pickle.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
@@ -161,7 +162,7 @@ bool FileSystemUsageCache::Delete(const base::FilePath& usage_file_path) {
 void FileSystemUsageCache::CloseCacheFiles() {
   TRACE_EVENT0("FileSystem", "UsageCache::CloseCacheFiles");
   DCHECK(CalledOnValidThread());
-  STLDeleteValues(&cache_files_);
+  cache_files_.clear();
   timer_.reset();
 }
 
@@ -228,24 +229,22 @@ base::File* FileSystemUsageCache::GetFile(const base::FilePath& file_path) {
     CloseCacheFiles();
   ScheduleCloseTimer();
 
-  base::File* new_file = NULL;
-  std::pair<CacheFiles::iterator, bool> inserted =
-      cache_files_.insert(std::make_pair(file_path, new_file));
-  if (!inserted.second)
-    return inserted.first->second;
-
-  new_file = new base::File(file_path,
-                            base::File::FLAG_OPEN_ALWAYS |
-                            base::File::FLAG_READ |
-                            base::File::FLAG_WRITE);
-  if (!new_file->IsValid()) {
-    cache_files_.erase(inserted.first);
-    delete new_file;
-    return NULL;
+  auto& entry = cache_files_[file_path];
+  if (entry)
+    return entry.get();
+
+  // Because there are no null entries in cache_files_, the [] inserted a blank
+  // pointer, so let's populate the cache.
+  entry = base::MakeUnique<base::File>(file_path, base::File::FLAG_OPEN_ALWAYS |
+                                                      base::File::FLAG_READ |
+                                                      base::File::FLAG_WRITE);
+
+  if (!entry->IsValid()) {
+    cache_files_.erase(file_path);
+    return nullptr;
   }
 
-  inserted.first->second = new_file;
-  return new_file;
+  return entry.get();
 }
 
 bool FileSystemUsageCache::ReadBytes(const base::FilePath& file_path,
@@ -300,7 +299,7 @@ bool FileSystemUsageCache::CalledOnValidThread() {
 bool FileSystemUsageCache::HasCacheFileHandle(const base::FilePath& file_path) {
   DCHECK(CalledOnValidThread());
   DCHECK_LE(cache_files_.size(), kMaxHandleCacheSize);
-  return ContainsKey(cache_files_, file_path);
+  return base::ContainsKey(cache_files_, file_path);
 }
 
 }  // namespace storage
diff --git a/chromium/storage/browser/fileapi/file_system_usage_cache.h b/chromium/storage/browser/fileapi/file_system_usage_cache.h
index 2ce570cbe31..98dd9227048 100644
--- a/chromium/storage/browser/fileapi/file_system_usage_cache.h
+++ b/chromium/storage/browser/fileapi/file_system_usage_cache.h
@@ -63,8 +63,6 @@ class STORAGE_EXPORT FileSystemUsageCache {
   static const int kUsageFileHeaderSize;
 
  private:
-  typedef std::map<base::FilePath, base::File*> CacheFiles;
-
   // Read the size, validity and the "dirty" entry described in the .usage file.
   // Returns less than zero if no .usage file is available.
   bool Read(const base::FilePath& usage_file_path,
@@ -93,7 +91,7 @@ class STORAGE_EXPORT FileSystemUsageCache {
   bool CalledOnValidThread();
 
   std::unique_ptr<TimedTaskHelper> timer_;
-  CacheFiles cache_files_;
+  std::map<base::FilePath, std::unique_ptr<base::File>> cache_files_;
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
diff --git a/chromium/storage/browser/fileapi/file_writer_delegate.cc b/chromium/storage/browser/fileapi/file_writer_delegate.cc
index 97327938b82..f84ae46879c 100644
--- a/chromium/storage/browser/fileapi/file_writer_delegate.cc
+++ b/chromium/storage/browser/fileapi/file_writer_delegate.cc
@@ -92,9 +92,12 @@ void FileWriterDelegate::OnSSLCertificateError(net::URLRequest* request,
   OnError(base::File::FILE_ERROR_SECURITY);
 }
 
-void FileWriterDelegate::OnResponseStarted(net::URLRequest* request) {
+void FileWriterDelegate::OnResponseStarted(net::URLRequest* request,
+                                           int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
   DCHECK_EQ(request_.get(), request);
-  if (!request->status().is_success() || request->GetResponseCode() != 200) {
+
+  if (net_error != net::OK || request->GetResponseCode() != 200) {
     OnError(base::File::FILE_ERROR_FAILED);
     return;
   }
@@ -103,8 +106,10 @@ void FileWriterDelegate::OnResponseStarted(net::URLRequest* request) {
 
 void FileWriterDelegate::OnReadCompleted(net::URLRequest* request,
                                          int bytes_read) {
+  DCHECK_NE(net::ERR_IO_PENDING, bytes_read);
   DCHECK_EQ(request_.get(), request);
-  if (!request->status().is_success()) {
+
+  if (bytes_read < 0) {
     OnError(base::File::FILE_ERROR_FAILED);
     return;
   }
@@ -113,19 +118,22 @@ void FileWriterDelegate::OnReadCompleted(net::URLRequest* request,
 
 void FileWriterDelegate::Read() {
   bytes_written_ = 0;
-  bytes_read_ = 0;
-  if (request_->Read(io_buffer_.get(), io_buffer_->size(), &bytes_read_)) {
+  bytes_read_ = request_->Read(io_buffer_.get(), io_buffer_->size());
+  if (bytes_read_ == net::ERR_IO_PENDING)
+    return;
+
+  if (bytes_read_ >= 0) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&FileWriterDelegate::OnDataReceived,
                               weak_factory_.GetWeakPtr(), bytes_read_));
-  } else if (!request_->status().is_io_pending()) {
+  } else {
     OnError(base::File::FILE_ERROR_FAILED);
   }
 }
 
 void FileWriterDelegate::OnDataReceived(int bytes_read) {
   bytes_read_ = bytes_read;
-  if (!bytes_read_) {  // We're done.
+  if (bytes_read == 0) {  // We're done.
     OnProgress(0, true);
   } else {
     // This could easily be optimized to rotate between a pool of buffers, so
diff --git a/chromium/storage/browser/fileapi/file_writer_delegate.h b/chromium/storage/browser/fileapi/file_writer_delegate.h
index 2323ea5cbdd..7520dc1811d 100644
--- a/chromium/storage/browser/fileapi/file_writer_delegate.h
+++ b/chromium/storage/browser/fileapi/file_writer_delegate.h
@@ -61,7 +61,7 @@ class STORAGE_EXPORT FileWriterDelegate : public net::URLRequest::Delegate {
   void OnSSLCertificateError(net::URLRequest* request,
                              const net::SSLInfo& ssl_info,
                              bool fatal) override;
-  void OnResponseStarted(net::URLRequest* request) override;
+  void OnResponseStarted(net::URLRequest* request, int net_error) override;
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override;
 
  private:
diff --git a/chromium/storage/browser/fileapi/isolated_context.cc b/chromium/storage/browser/fileapi/isolated_context.cc
index 6edc40d6c2b..5511fb79e85 100644
--- a/chromium/storage/browser/fileapi/isolated_context.cc
+++ b/chromium/storage/browser/fileapi/isolated_context.cc
@@ -9,8 +9,8 @@
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ -219,8 +219,8 @@ std::string IsolatedContext::RegisterDraggedFileSystem(
     const FileInfoSet& files) {
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
-  instance_map_[filesystem_id] = new Instance(
-      kFileSystemTypeDragged, files.fileset());
+  instance_map_[filesystem_id] =
+      base::MakeUnique<Instance>(kFileSystemTypeDragged, files.fileset());
   return filesystem_id;
 }
 
@@ -243,9 +243,8 @@ std::string IsolatedContext::RegisterFileSystemForPath(
 
   base::AutoLock locker(lock_);
   std::string new_id = GetNewFileSystemId();
-  instance_map_[new_id] = new Instance(type, filesystem_id,
-                                       MountPointInfo(name, path),
-                                       Instance::PLATFORM_PATH);
+  instance_map_[new_id] = base::MakeUnique<Instance>(
+      type, filesystem_id, MountPointInfo(name, path), Instance::PLATFORM_PATH);
   path_to_id_map_[path].insert(new_id);
   return new_id;
 }
@@ -259,7 +258,7 @@ std::string IsolatedContext::RegisterFileSystemForVirtualPath(
   if (path.ReferencesParent())
     return std::string();
   std::string filesystem_id = GetNewFileSystemId();
-  instance_map_[filesystem_id] = new Instance(
+  instance_map_[filesystem_id] = base::MakeUnique<Instance>(
       type,
       std::string(),  // filesystem_id
       MountPointInfo(register_name, cracked_path_prefix),
@@ -281,7 +280,7 @@ bool IsolatedContext::GetRegisteredPath(
     const std::string& filesystem_id, base::FilePath* path) const {
   DCHECK(path);
   base::AutoLock locker(lock_);
-  IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() || !found->second->IsSinglePathInstance())
     return false;
   *path = found->second->file_info().path;
@@ -319,11 +318,11 @@ bool IsolatedContext::CrackVirtualPath(
   base::FilePath cracked_path;
   {
     base::AutoLock locker(lock_);
-    IDToInstance::const_iterator found_instance = instance_map_.find(fsid);
+    auto found_instance = instance_map_.find(fsid);
     if (found_instance == instance_map_.end())
       return false;
     *id_or_name = fsid;
-    const Instance* instance = found_instance->second;
+    const Instance* instance = found_instance->second.get();
     if (type)
       *type = instance->type();
     if (cracked_id)
@@ -364,18 +363,12 @@ FileSystemURL IsolatedContext::CreateCrackedFileSystemURL(
 void IsolatedContext::RevokeFileSystemByPath(const base::FilePath& path_in) {
   base::AutoLock locker(lock_);
   base::FilePath path(path_in.NormalizePathSeparators());
-  PathToID::iterator ids_iter = path_to_id_map_.find(path);
+  auto ids_iter = path_to_id_map_.find(path);
   if (ids_iter == path_to_id_map_.end())
     return;
   std::set<std::string>& ids = ids_iter->second;
-  for (std::set<std::string>::iterator iter = ids.begin();
-       iter != ids.end(); ++iter) {
-    IDToInstance::iterator found = instance_map_.find(*iter);
-    if (found != instance_map_.end()) {
-      delete found->second;
-      instance_map_.erase(found);
-    }
-  }
+  for (auto iter = ids.begin(); iter != ids.end(); ++iter)
+    instance_map_.erase(*iter);
   path_to_id_map_.erase(ids_iter);
 }
 
@@ -389,10 +382,10 @@ void IsolatedContext::RemoveReference(const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
   // This could get called for non-existent filesystem if it has been
   // already deleted by RevokeFileSystemByPath.
-  IDToInstance::iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end())
     return;
-  Instance* instance = found->second;
+  Instance* instance = found->second.get();
   DCHECK_GT(instance->ref_counts(), 0);
   instance->RemoveRef();
   if (instance->ref_counts() == 0) {
@@ -406,7 +399,7 @@ bool IsolatedContext::GetDraggedFileInfo(
     std::vector<MountPointInfo>* files) const {
   DCHECK(files);
   base::AutoLock locker(lock_);
-  IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() ||
       found->second->type() != kFileSystemTypeDragged)
     return false;
@@ -420,13 +413,9 @@ base::FilePath IsolatedContext::CreateVirtualRootPath(
   return base::FilePath().AppendASCII(filesystem_id);
 }
 
-IsolatedContext::IsolatedContext() {
-}
+IsolatedContext::IsolatedContext() = default;
 
-IsolatedContext::~IsolatedContext() {
-  STLDeleteContainerPairSecondPointers(instance_map_.begin(),
-                                       instance_map_.end());
-}
+IsolatedContext::~IsolatedContext() = default;
 
 FileSystemURL IsolatedContext::CrackFileSystemURL(
     const FileSystemURL& url) const {
@@ -454,19 +443,17 @@ FileSystemURL IsolatedContext::CrackFileSystemURL(
 
 bool IsolatedContext::UnregisterFileSystem(const std::string& filesystem_id) {
   lock_.AssertAcquired();
-  IDToInstance::iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end())
     return false;
-  Instance* instance = found->second;
+  Instance* instance = found->second.get();
   if (instance->IsSinglePathInstance()) {
-    PathToID::iterator ids_iter = path_to_id_map_.find(
-        instance->file_info().path);
+    auto ids_iter = path_to_id_map_.find(instance->file_info().path);
     DCHECK(ids_iter != path_to_id_map_.end());
     ids_iter->second.erase(filesystem_id);
     if (ids_iter->second.empty())
       path_to_id_map_.erase(ids_iter);
   }
-  delete found->second;
   instance_map_.erase(found);
   return true;
 }
diff --git a/chromium/storage/browser/fileapi/isolated_context.h b/chromium/storage/browser/fileapi/isolated_context.h
index b89045bd35b..1f1c1d91f00 100644
--- a/chromium/storage/browser/fileapi/isolated_context.h
+++ b/chromium/storage/browser/fileapi/isolated_context.h
@@ -166,11 +166,6 @@ class STORAGE_EXPORT IsolatedContext : public MountPoints {
   // Represents each file system instance (defined in the .cc).
   class Instance;
 
-  typedef std::map<std::string, Instance*> IDToInstance;
-
-  // Reverse map from registered path to IDs.
-  typedef std::map<base::FilePath, std::set<std::string> > PathToID;
-
   // Obtain an instance of this class via GetInstance().
   IsolatedContext();
   ~IsolatedContext() override;
@@ -188,8 +183,10 @@ class STORAGE_EXPORT IsolatedContext : public MountPoints {
   // This lock needs to be obtained when accessing the instance_map_.
   mutable base::Lock lock_;
 
-  IDToInstance instance_map_;
-  PathToID path_to_id_map_;
+  std::map<std::string, std::unique_ptr<Instance>> instance_map_;
+
+  // Reverse map from registered path to IDs.
+  std::map<base::FilePath, std::set<std::string>> path_to_id_map_;
 
   DISALLOW_COPY_AND_ASSIGN(IsolatedContext);
 };
diff --git a/chromium/storage/browser/fileapi/isolated_file_system_backend.cc b/chromium/storage/browser/fileapi/isolated_file_system_backend.cc
index 78518e9b32f..34ed14cac78 100644
--- a/chromium/storage/browser/fileapi/isolated_file_system_backend.cc
+++ b/chromium/storage/browser/fileapi/isolated_file_system_backend.cc
@@ -110,7 +110,7 @@ FileSystemOperation* IsolatedFileSystemBackend::CreateFileSystemOperation(
     FileSystemContext* context,
     base::File::Error* error_code) const {
   return FileSystemOperation::Create(
-      url, context, base::WrapUnique(new FileSystemOperationContext(context)));
+      url, context, base::MakeUnique<FileSystemOperationContext>(context));
 }
 
 bool IsolatedFileSystemBackend::SupportsStreaming(
diff --git a/chromium/storage/browser/fileapi/local_file_util.cc b/chromium/storage/browser/fileapi/local_file_util.cc
index 02268996e2f..32ce0dd7b17 100644
--- a/chromium/storage/browser/fileapi/local_file_util.cc
+++ b/chromium/storage/browser/fileapi/local_file_util.cc
@@ -145,9 +145,9 @@ LocalFileUtil::CreateFileEnumerator(FileSystemOperationContext* context,
       base::File::FILE_OK) {
     return base::WrapUnique(new EmptyFileEnumerator);
   }
-  return base::WrapUnique(new LocalFileEnumerator(
+  return base::MakeUnique<LocalFileEnumerator>(
       file_path, root_url.path(),
-      base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES));
+      base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES);
 }
 
 base::File::Error LocalFileUtil::GetLocalFilePath(
diff --git a/chromium/storage/browser/fileapi/native_file_util.cc b/chromium/storage/browser/fileapi/native_file_util.cc
index aa2b6077115..1d61f62210a 100644
--- a/chromium/storage/browser/fileapi/native_file_util.cc
+++ b/chromium/storage/browser/fileapi/native_file_util.cc
@@ -211,9 +211,9 @@ base::File::Error NativeFileUtil::GetFileInfo(
 std::unique_ptr<FileSystemFileUtil::AbstractFileEnumerator>
 NativeFileUtil::CreateFileEnumerator(const base::FilePath& root_path,
                                      bool recursive) {
-  return base::WrapUnique(new NativeFileEnumerator(
+  return base::MakeUnique<NativeFileEnumerator>(
       root_path, recursive,
-      base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES));
+      base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES);
 }
 
 base::File::Error NativeFileUtil::Touch(
diff --git a/chromium/storage/browser/fileapi/obfuscated_file_util.cc b/chromium/storage/browser/fileapi/obfuscated_file_util.cc
index 009ba44020b..9ff8148928d 100644
--- a/chromium/storage/browser/fileapi/obfuscated_file_util.cc
+++ b/chromium/storage/browser/fileapi/obfuscated_file_util.cc
@@ -14,9 +14,9 @@
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ -110,7 +110,7 @@ enum IsolatedOriginStatus {
 
 }  // namespace
 
-class ObfuscatedFileEnumerator
+class ObfuscatedFileEnumerator final
     : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
   ObfuscatedFileEnumerator(
@@ -138,21 +138,21 @@ class ObfuscatedFileEnumerator
   ~ObfuscatedFileEnumerator() override {}
 
   base::FilePath Next() override {
-    ProcessRecurseQueue();
-    if (display_stack_.empty())
-      return base::FilePath();
+    FileInfo file_info;
+    base::File::Error error;
+    do {
+      ProcessRecurseQueue();
+      if (display_stack_.empty())
+        return base::FilePath();
 
-    current_file_id_ = display_stack_.back();
-    display_stack_.pop_back();
+      current_file_id_ = display_stack_.back();
+      display_stack_.pop_back();
 
-    FileInfo file_info;
-    base::FilePath platform_file_path;
-    base::File::Error error =
-        obfuscated_file_util_->GetFileInfoInternal(
-            db_, context_, root_url_, current_file_id_,
-            &file_info, &current_platform_file_info_, &platform_file_path);
-    if (error != base::File::FILE_OK)
-      return Next();
+      base::FilePath platform_file_path;
+      error = obfuscated_file_util_->GetFileInfoInternal(
+          db_, context_, root_url_, current_file_id_,
+          &file_info, &current_platform_file_info_, &platform_file_path);
+    } while (error != base::File::FILE_OK);
 
     base::FilePath virtual_path =
         current_parent_virtual_path_.Append(file_info.name);
@@ -903,13 +903,12 @@ void ObfuscatedFileUtil::CloseFileSystemForOriginAndType(
     const GURL& origin,
     const std::string& type_string) {
   const std::string key_prefix = GetDirectoryDatabaseKey(origin, type_string);
-  for (DirectoryMap::iterator iter = directories_.lower_bound(key_prefix);
+  for (auto iter = directories_.lower_bound(key_prefix);
        iter != directories_.end();) {
     if (!base::StartsWith(iter->first, key_prefix,
                           base::CompareCase::SENSITIVE))
       break;
     DCHECK(type_string.empty() || iter->first == key_prefix);
-    std::unique_ptr<SandboxDirectoryDatabase> database(iter->second);
     directories_.erase(iter++);
   }
 }
@@ -928,13 +927,14 @@ void ObfuscatedFileUtil::DestroyDirectoryDatabase(
     const std::string& type_string) {
   // If |type_string| is empty, delete all filesystem types under |origin|.
   const std::string key_prefix = GetDirectoryDatabaseKey(origin, type_string);
-  for (DirectoryMap::iterator iter = directories_.lower_bound(key_prefix);
+  for (auto iter = directories_.lower_bound(key_prefix);
        iter != directories_.end();) {
     if (!base::StartsWith(iter->first, key_prefix,
                           base::CompareCase::SENSITIVE))
       break;
     DCHECK(type_string.empty() || iter->first == key_prefix);
-    std::unique_ptr<SandboxDirectoryDatabase> database(iter->second);
+    std::unique_ptr<SandboxDirectoryDatabase> database =
+        std::move(iter->second);
     directories_.erase(iter++);
 
     // Continue to destroy databases even if it failed because it doesn't affect
@@ -962,17 +962,18 @@ void ObfuscatedFileUtil::MaybePrepopulateDatabase(
   for (size_t i = 0; i < type_strings_to_prepopulate.size(); ++i) {
     const std::string type_string = type_strings_to_prepopulate[i];
     // Only handles known types.
-    if (!ContainsKey(known_type_strings_, type_string))
+    if (!base::ContainsKey(known_type_strings_, type_string))
       continue;
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = GetDirectoryForOriginAndType(
         origin, type_string, false, &error);
     if (error != base::File::FILE_OK)
       continue;
-    std::unique_ptr<SandboxDirectoryDatabase> db(
-        new SandboxDirectoryDatabase(path, env_override_));
+    std::unique_ptr<SandboxDirectoryDatabase> db =
+        base::MakeUnique<SandboxDirectoryDatabase>(path, env_override_);
     if (db->Init(SandboxDirectoryDatabase::FAIL_ON_CORRUPTION)) {
-      directories_[GetDirectoryDatabaseKey(origin, type_string)] = db.release();
+      directories_[GetDirectoryDatabaseKey(origin, type_string)] =
+          std::move(db);
       MarkUsed();
       // Don't populate more than one database, as it may rather hurt
       // performance.
@@ -1168,10 +1169,10 @@ SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
   if (key.empty())
     return NULL;
 
-  DirectoryMap::iterator iter = directories_.find(key);
+  auto iter = directories_.find(key);
   if (iter != directories_.end()) {
     MarkUsed();
-    return iter->second;
+    return iter->second.get();
   }
 
   base::File::Error error = base::File::FILE_OK;
@@ -1182,10 +1183,9 @@ SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
     return NULL;
   }
   MarkUsed();
-  SandboxDirectoryDatabase* database =
-      new SandboxDirectoryDatabase(path, env_override_);
-  directories_[key] = database;
-  return database;
+  directories_[key] =
+      base::MakeUnique<SandboxDirectoryDatabase>(path, env_override_);
+  return directories_[key].get();
 }
 
 base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
@@ -1264,8 +1264,6 @@ void ObfuscatedFileUtil::MarkUsed() {
 
 void ObfuscatedFileUtil::DropDatabases() {
   origin_database_.reset();
-  STLDeleteContainerPairSecondPointers(
-      directories_.begin(), directories_.end());
   directories_.clear();
   timer_.reset();
 }
diff --git a/chromium/storage/browser/fileapi/obfuscated_file_util.h b/chromium/storage/browser/fileapi/obfuscated_file_util.h
index 1ecfc4cdaa7..fc56e81d72b 100644
--- a/chromium/storage/browser/fileapi/obfuscated_file_util.h
+++ b/chromium/storage/browser/fileapi/obfuscated_file_util.h
@@ -327,8 +327,7 @@ class STORAGE_EXPORT ObfuscatedFileUtil : public FileSystemFileUtil {
 
   bool HasIsolatedStorage(const GURL& origin);
 
-  typedef std::map<std::string, SandboxDirectoryDatabase*> DirectoryMap;
-  DirectoryMap directories_;
+  std::map<std::string, std::unique_ptr<SandboxDirectoryDatabase>> directories_;
   std::unique_ptr<SandboxOriginDatabaseInterface> origin_database_;
   scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
   base::FilePath file_system_directory_;
diff --git a/chromium/storage/browser/fileapi/plugin_private_file_system_backend.cc b/chromium/storage/browser/fileapi/plugin_private_file_system_backend.cc
index 54b0e7f7ce2..06e9aefb3f1 100644
--- a/chromium/storage/browser/fileapi/plugin_private_file_system_backend.cc
+++ b/chromium/storage/browser/fileapi/plugin_private_file_system_backend.cc
@@ -48,7 +48,7 @@ class PluginPrivateFileSystemBackend::FileSystemIDToPluginMap {
                           const std::string& plugin_id) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     DCHECK(!filesystem_id.empty());
-    DCHECK(!ContainsKey(map_, filesystem_id)) << filesystem_id;
+    DCHECK(!base::ContainsKey(map_, filesystem_id)) << filesystem_id;
     map_[filesystem_id] = plugin_id;
   }
 
diff --git a/chromium/storage/browser/fileapi/quota/open_file_handle.cc b/chromium/storage/browser/fileapi/quota/open_file_handle.cc
index 3c4f01d4b05..dd809c51086 100644
--- a/chromium/storage/browser/fileapi/quota/open_file_handle.cc
+++ b/chromium/storage/browser/fileapi/quota/open_file_handle.cc
@@ -12,11 +12,11 @@
 namespace storage {
 
 OpenFileHandle::~OpenFileHandle() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 }
 
 void OpenFileHandle::UpdateMaxWrittenOffset(int64_t offset) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   int64_t growth = context_->UpdateMaxWrittenOffset(offset);
   if (growth > 0)
@@ -24,7 +24,7 @@ void OpenFileHandle::UpdateMaxWrittenOffset(int64_t offset) {
 }
 
 void OpenFileHandle::AddAppendModeWriteAmount(int64_t amount) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   if (amount <= 0)
     return;
 
@@ -33,17 +33,17 @@ void OpenFileHandle::AddAppendModeWriteAmount(int64_t amount) {
 }
 
 int64_t OpenFileHandle::GetEstimatedFileSize() const {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return context_->GetEstimatedFileSize();
 }
 
 int64_t OpenFileHandle::GetMaxWrittenOffset() const {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return context_->GetMaxWrittenOffset();
 }
 
 const base::FilePath& OpenFileHandle::platform_path() const {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return context_->platform_path();
 }
 
@@ -51,7 +51,7 @@ OpenFileHandle::OpenFileHandle(QuotaReservation* reservation,
                                OpenFileHandleContext* context)
     : reservation_(reservation),
       context_(context) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 }
 
 }  // namespace storage
diff --git a/chromium/storage/browser/fileapi/quota/open_file_handle_context.cc b/chromium/storage/browser/fileapi/quota/open_file_handle_context.cc
index 1feabce6a25..911a2f96530 100644
--- a/chromium/storage/browser/fileapi/quota/open_file_handle_context.cc
+++ b/chromium/storage/browser/fileapi/quota/open_file_handle_context.cc
@@ -19,14 +19,14 @@ OpenFileHandleContext::OpenFileHandleContext(
       append_mode_write_amount_(0),
       platform_path_(platform_path),
       reservation_buffer_(reservation_buffer) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   base::GetFileSize(platform_path, &initial_file_size_);
   maximum_written_offset_ = initial_file_size_;
 }
 
 int64_t OpenFileHandleContext::UpdateMaxWrittenOffset(int64_t offset) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   if (offset <= maximum_written_offset_)
     return 0;
 
@@ -36,22 +36,22 @@ int64_t OpenFileHandleContext::UpdateMaxWrittenOffset(int64_t offset) {
 }
 
 void OpenFileHandleContext::AddAppendModeWriteAmount(int64_t amount) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   append_mode_write_amount_ += amount;
 }
 
 int64_t OpenFileHandleContext::GetEstimatedFileSize() const {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return maximum_written_offset_ + append_mode_write_amount_;
 }
 
 int64_t OpenFileHandleContext::GetMaxWrittenOffset() const {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return maximum_written_offset_;
 }
 
 OpenFileHandleContext::~OpenFileHandleContext() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   // TODO(tzik): Optimize this for single operation.
 
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation.cc b/chromium/storage/browser/fileapi/quota/quota_reservation.cc
index e1a8ea0d728..48fb46d0620 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation.cc
@@ -16,7 +16,7 @@ namespace storage {
 
 void QuotaReservation::RefreshReservation(int64_t size,
                                           const StatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(!running_refresh_request_);
   DCHECK(!client_crashed_);
   if (!reservation_manager())
@@ -36,13 +36,13 @@ void QuotaReservation::RefreshReservation(int64_t size,
 
 std::unique_ptr<OpenFileHandle> QuotaReservation::GetOpenFileHandle(
     const base::FilePath& platform_path) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(!client_crashed_);
   return reservation_buffer_->GetOpenFileHandle(this, platform_path);
 }
 
 void QuotaReservation::OnClientCrash() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   client_crashed_ = true;
 
   if (remaining_quota_) {
@@ -52,7 +52,7 @@ void QuotaReservation::OnClientCrash() {
 }
 
 void QuotaReservation::ConsumeReservation(int64_t size) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_LT(0, size);
   DCHECK_LE(size, remaining_quota_);
   if (client_crashed_)
@@ -81,11 +81,11 @@ QuotaReservation::QuotaReservation(
       remaining_quota_(0),
       reservation_buffer_(reservation_buffer),
       weak_ptr_factory_(this) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 }
 
 QuotaReservation::~QuotaReservation() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (remaining_quota_ && reservation_manager()) {
     reservation_manager()->ReleaseReservedQuota(
@@ -111,7 +111,7 @@ bool QuotaReservation::DidUpdateReservedQuota(int64_t previous_size,
                                               const StatusCallback& callback,
                                               base::File::Error error,
                                               int64_t delta) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(running_refresh_request_);
   running_refresh_request_ = false;
 
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.cc b/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.cc
index 6d6930af0e6..4f88036ac44 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.cc
@@ -25,19 +25,19 @@ QuotaReservationBuffer::QuotaReservationBuffer(
       type_(type),
       reserved_quota_(0) {
   DCHECK(origin.is_valid());
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   reservation_manager_->IncrementDirtyCount(origin, type);
 }
 
 scoped_refptr<QuotaReservation> QuotaReservationBuffer::CreateReservation() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return make_scoped_refptr(new QuotaReservation(this));
 }
 
 std::unique_ptr<OpenFileHandle> QuotaReservationBuffer::GetOpenFileHandle(
     QuotaReservation* reservation,
     const base::FilePath& platform_path) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   OpenFileHandleContext** open_file = &open_files_[platform_path];
   if (!*open_file)
     *open_file = new OpenFileHandleContext(platform_path, this);
@@ -47,7 +47,7 @@ std::unique_ptr<OpenFileHandle> QuotaReservationBuffer::GetOpenFileHandle(
 void QuotaReservationBuffer::CommitFileGrowth(
     int64_t reserved_quota_consumption,
     int64_t usage_delta) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   if (!reservation_manager_)
     return;
   reservation_manager_->CommitQuotaUsage(origin_, type_, usage_delta);
@@ -67,19 +67,19 @@ void QuotaReservationBuffer::CommitFileGrowth(
 
 void QuotaReservationBuffer::DetachOpenFileHandleContext(
     OpenFileHandleContext* open_file) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_EQ(open_file, open_files_[open_file->platform_path()]);
   open_files_.erase(open_file->platform_path());
 }
 
 void QuotaReservationBuffer::PutReservationToBuffer(int64_t reservation) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_LE(0, reservation);
   reserved_quota_ += reservation;
 }
 
 QuotaReservationBuffer::~QuotaReservationBuffer() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   if (!reservation_manager_)
     return;
 
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation_manager.cc b/chromium/storage/browser/fileapi/quota/quota_reservation_manager.cc
index e182e7ec2da..b4055dd8f14 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation_manager.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation_manager.cc
@@ -21,7 +21,7 @@ QuotaReservationManager::QuotaReservationManager(
 }
 
 QuotaReservationManager::~QuotaReservationManager() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 }
 
 void QuotaReservationManager::ReserveQuota(
@@ -63,7 +63,7 @@ scoped_refptr<QuotaReservationBuffer>
 QuotaReservationManager::GetReservationBuffer(
     const GURL& origin,
     FileSystemType type) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(origin.is_valid());
   QuotaReservationBuffer** buffer =
       &reservation_buffers_[std::make_pair(origin, type)];
@@ -76,7 +76,7 @@ QuotaReservationManager::GetReservationBuffer(
 
 void QuotaReservationManager::ReleaseReservationBuffer(
     QuotaReservationBuffer* reservation_buffer) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   std::pair<GURL, FileSystemType> key(reservation_buffer->origin(),
                                       reservation_buffer->type());
   DCHECK_EQ(reservation_buffers_[key], reservation_buffer);
diff --git a/chromium/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc b/chromium/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc
index f4714c78b1d..9063fb0210e 100644
--- a/chromium/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc
+++ b/chromium/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc
@@ -13,7 +13,7 @@
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "net/base/url_util.h"
@@ -393,7 +393,8 @@ int64_t SandboxFileSystemBackendDelegate::GetOriginUsageOnFileTaskRunner(
 
   // Don't use usage cache and return recalculated usage for sticky invalidated
   // origins.
-  if (ContainsKey(sticky_dirty_origins_, std::make_pair(origin_url, type)))
+  if (base::ContainsKey(sticky_dirty_origins_,
+                        std::make_pair(origin_url, type)))
     return RecalculateUsage(file_system_context, origin_url, type);
 
   base::FilePath base_path =
diff --git a/chromium/storage/browser/quota/client_usage_tracker.cc b/chromium/storage/browser/quota/client_usage_tracker.cc
index 477fdb5e932..c9c46f6d1a0 100644
--- a/chromium/storage/browser/quota/client_usage_tracker.cc
+++ b/chromium/storage/browser/quota/client_usage_tracker.cc
@@ -46,7 +46,7 @@ bool OriginSetContainsOrigin(const OriginSetByHost& origins,
                              const std::string& host,
                              const GURL& origin) {
   OriginSetByHost::const_iterator itr = origins.find(host);
-  return itr != origins.end() && ContainsKey(itr->second, origin);
+  return itr != origins.end() && base::ContainsKey(itr->second, origin);
 }
 
 void DidGetGlobalUsageForLimitedGlobalUsage(const UsageCallback& callback,
@@ -122,9 +122,9 @@ void ClientUsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
 
 void ClientUsageTracker::GetHostUsage(
     const std::string& host, const UsageCallback& callback) {
-  if (ContainsKey(cached_hosts_, host) &&
-      !ContainsKey(non_cached_limited_origins_by_host_, host) &&
-      !ContainsKey(non_cached_unlimited_origins_by_host_, host)) {
+  if (base::ContainsKey(cached_hosts_, host) &&
+      !base::ContainsKey(non_cached_limited_origins_by_host_, host) &&
+      !base::ContainsKey(non_cached_unlimited_origins_by_host_, host)) {
     // TODO(kinuko): Drop host_usage_map_ cache periodically.
     callback.Run(GetCachedHostUsage(host));
     return;
diff --git a/chromium/storage/browser/quota/quota_manager.cc b/chromium/storage/browser/quota/quota_manager.cc
index 79268a61a29..44ba5f1019d 100644
--- a/chromium/storage/browser/quota/quota_manager.cc
+++ b/chromium/storage/browser/quota/quota_manager.cc
@@ -18,7 +18,7 @@
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
@@ -1578,8 +1578,8 @@ void QuotaManager::DidGetEvictionOrigin(const GetOriginCallback& callback,
                                         const GURL& origin) {
   // Make sure the returned origin is (still) not in the origin_in_use_ set
   // and has not been accessed since we posted the task.
-  if (ContainsKey(origins_in_use_, origin) ||
-      ContainsKey(access_notified_origins_, origin)) {
+  if (base::ContainsKey(origins_in_use_, origin) ||
+      base::ContainsKey(access_notified_origins_, origin)) {
     callback.Run(GURL());
   } else {
     callback.Run(origin);
diff --git a/chromium/storage/browser/quota/storage_monitor.cc b/chromium/storage/browser/quota/storage_monitor.cc
index a0d351fbdd1..eafa5a6e7f7 100644
--- a/chromium/storage/browser/quota/storage_monitor.cc
+++ b/chromium/storage/browser/quota/storage_monitor.cc
@@ -8,7 +8,7 @@
 
 #include <algorithm>
 
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/url_util.h"
 #include "storage/browser/quota/quota_manager.h"
@@ -119,7 +119,7 @@ void StorageObserverList::MaybeDispatchEvent(
 }
 
 void StorageObserverList::ScheduleUpdateForObserver(StorageObserver* observer) {
-  DCHECK(ContainsKey(observers_, observer));
+  DCHECK(base::ContainsKey(observers_, observer));
   observers_[observer].requires_update = true;
 }
 
@@ -247,7 +247,6 @@ StorageTypeObservers::StorageTypeObservers(QuotaManager* quota_manager)
 }
 
 StorageTypeObservers::~StorageTypeObservers() {
-  STLDeleteValues(&host_observers_map_);
 }
 
 void StorageTypeObservers::AddObserver(
@@ -256,25 +255,22 @@ void StorageTypeObservers::AddObserver(
   if (host.empty())
     return;
 
-  HostStorageObservers* host_observers = NULL;
-  HostObserversMap::iterator it = host_observers_map_.find(host);
-  if (it == host_observers_map_.end()) {
-    host_observers = new HostStorageObservers(quota_manager_);
-    host_observers_map_[host] = host_observers;
-  } else {
-    host_observers = it->second;
+  auto& host_observers = host_observers_map_[host];
+  if (!host_observers) {
+    // Because there are no null entries in host_observers_map_, the [] inserted
+    // a blank pointer, so let's populate it.
+    host_observers = base::MakeUnique<HostStorageObservers>(quota_manager_);
   }
 
   host_observers->AddObserver(observer, params);
 }
 
 void StorageTypeObservers::RemoveObserver(StorageObserver* observer) {
-  for (HostObserversMap::iterator it = host_observers_map_.begin();
-       it != host_observers_map_.end(); ) {
+  for (auto it = host_observers_map_.begin();
+       it != host_observers_map_.end();) {
     it->second->RemoveObserver(observer);
     if (!it->second->ContainsObservers()) {
-      delete it->second;
-      host_observers_map_.erase(it++);
+      it = host_observers_map_.erase(it);
     } else {
       ++it;
     }
@@ -284,31 +280,29 @@ void StorageTypeObservers::RemoveObserver(StorageObserver* observer) {
 void StorageTypeObservers::RemoveObserverForFilter(
     StorageObserver* observer, const StorageObserver::Filter& filter) {
   std::string host = net::GetHostOrSpecFromURL(filter.origin);
-  HostObserversMap::iterator it = host_observers_map_.find(host);
+  auto it = host_observers_map_.find(host);
   if (it == host_observers_map_.end())
     return;
 
   it->second->RemoveObserver(observer);
-  if (!it->second->ContainsObservers()) {
-    delete it->second;
+  if (!it->second->ContainsObservers())
     host_observers_map_.erase(it);
-  }
 }
 
 const HostStorageObservers* StorageTypeObservers::GetHostObservers(
     const std::string& host) const {
-  HostObserversMap::const_iterator it = host_observers_map_.find(host);
+  auto it = host_observers_map_.find(host);
   if (it != host_observers_map_.end())
-    return it->second;
+    return it->second.get();
 
-  return NULL;
+  return nullptr;
 }
 
 void StorageTypeObservers::NotifyUsageChange(
     const StorageObserver::Filter& filter,
     int64_t delta) {
   std::string host = net::GetHostOrSpecFromURL(filter.origin);
-  HostObserversMap::iterator it = host_observers_map_.find(host);
+  auto it = host_observers_map_.find(host);
   if (it == host_observers_map_.end())
     return;
 
@@ -323,7 +317,6 @@ StorageMonitor::StorageMonitor(QuotaManager* quota_manager)
 }
 
 StorageMonitor::~StorageMonitor() {
-  STLDeleteValues(&storage_type_observers_map_);
 }
 
 void StorageMonitor::AddObserver(
@@ -338,22 +331,16 @@ void StorageMonitor::AddObserver(
     return;
   }
 
-  StorageTypeObservers* type_observers = NULL;
-  StorageTypeObserversMap::iterator it =
-      storage_type_observers_map_.find(params.filter.storage_type);
-  if (it == storage_type_observers_map_.end()) {
-    type_observers = new StorageTypeObservers(quota_manager_);
-    storage_type_observers_map_[params.filter.storage_type] = type_observers;
-  } else {
-    type_observers = it->second;
-  }
+  auto& type_observers =
+      storage_type_observers_map_[params.filter.storage_type];
+  if (!type_observers)
+    type_observers = base::MakeUnique<StorageTypeObservers>(quota_manager_);
 
   type_observers->AddObserver(observer, params);
 }
 
 void StorageMonitor::RemoveObserver(StorageObserver* observer) {
-  for (StorageTypeObserversMap::iterator it =
-           storage_type_observers_map_.begin();
+  for (auto it = storage_type_observers_map_.begin();
        it != storage_type_observers_map_.end(); ++it) {
     it->second->RemoveObserver(observer);
   }
@@ -361,8 +348,7 @@ void StorageMonitor::RemoveObserver(StorageObserver* observer) {
 
 void StorageMonitor::RemoveObserverForFilter(
     StorageObserver* observer, const StorageObserver::Filter& filter) {
-  StorageTypeObserversMap::iterator it =
-      storage_type_observers_map_.find(filter.storage_type);
+  auto it = storage_type_observers_map_.find(filter.storage_type);
   if (it == storage_type_observers_map_.end())
     return;
 
@@ -371,12 +357,11 @@ void StorageMonitor::RemoveObserverForFilter(
 
 const StorageTypeObservers* StorageMonitor::GetStorageTypeObservers(
     StorageType storage_type) const {
-  StorageTypeObserversMap::const_iterator it =
-      storage_type_observers_map_.find(storage_type);
+  auto it = storage_type_observers_map_.find(storage_type);
   if (it != storage_type_observers_map_.end())
-    return it->second;
+    return it->second.get();
 
-  return NULL;
+  return nullptr;
 }
 
 void StorageMonitor::NotifyUsageChange(const StorageObserver::Filter& filter,
@@ -389,8 +374,7 @@ void StorageMonitor::NotifyUsageChange(const StorageObserver::Filter& filter,
     return;
   }
 
-  StorageTypeObserversMap::iterator it =
-      storage_type_observers_map_.find(filter.storage_type);
+  auto it = storage_type_observers_map_.find(filter.storage_type);
   if (it == storage_type_observers_map_.end())
     return;
 
diff --git a/chromium/storage/browser/quota/storage_monitor.h b/chromium/storage/browser/quota/storage_monitor.h
index d2158040ffd..01cb447b8fe 100644
--- a/chromium/storage/browser/quota/storage_monitor.h
+++ b/chromium/storage/browser/quota/storage_monitor.h
@@ -8,6 +8,7 @@
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ -140,10 +141,9 @@ class STORAGE_EXPORT StorageTypeObservers {
   void NotifyUsageChange(const StorageObserver::Filter& filter, int64_t delta);
 
  private:
-  typedef std::map<std::string, HostStorageObservers*> HostObserversMap;
-
   QuotaManager* quota_manager_;
-  HostObserversMap host_observers_map_;
+  std::map<std::string, std::unique_ptr<HostStorageObservers>>
+      host_observers_map_;
 
   DISALLOW_COPY_AND_ASSIGN(StorageTypeObservers);
 };
@@ -170,10 +170,9 @@ class STORAGE_EXPORT StorageMonitor {
   void NotifyUsageChange(const StorageObserver::Filter& filter, int64_t delta);
 
  private:
-  typedef std::map<StorageType, StorageTypeObservers*> StorageTypeObserversMap;
-
   QuotaManager* quota_manager_;
-  StorageTypeObserversMap storage_type_observers_map_;
+  std::map<StorageType, std::unique_ptr<StorageTypeObservers>>
+      storage_type_observers_map_;
 
   DISALLOW_COPY_AND_ASSIGN(StorageMonitor);
 };
diff --git a/chromium/storage/browser/quota/usage_tracker.cc b/chromium/storage/browser/quota/usage_tracker.cc
index 7c96a247b4d..e324bfe7d28 100644
--- a/chromium/storage/browser/quota/usage_tracker.cc
+++ b/chromium/storage/browser/quota/usage_tracker.cc
@@ -32,7 +32,7 @@ UsageTracker::UsageTracker(const QuotaClientList& clients,
     : type_(type),
       storage_monitor_(storage_monitor),
       weak_factory_(this) {
-  for (const auto& client : clients) {
+  for (auto* client : clients) {
     if (client->DoesSupport(type)) {
       client_tracker_map_[client->id()] =
           new ClientUsageTracker(this, client, type, special_storage_policy,
@@ -42,7 +42,7 @@ UsageTracker::UsageTracker(const QuotaClientList& clients,
 }
 
 UsageTracker::~UsageTracker() {
-  STLDeleteValues(&client_tracker_map_);
+  base::STLDeleteValues(&client_tracker_map_);
 }
 
 ClientUsageTracker* UsageTracker::GetClientTracker(QuotaClient::ID client_id) {
diff --git a/chromium/storage/common/BUILD.gn b/chromium/storage/common/BUILD.gn
index a524eff74ce..03766c3a20b 100644
--- a/chromium/storage/common/BUILD.gn
+++ b/chromium/storage/common/BUILD.gn
@@ -2,7 +2,6 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-# GYP version: storage/storage_common.gyp:storage_common
 component("common") {
   output_name = "storage_common"
   sources = [
diff --git a/chromium/storage/common/fileapi/file_system_util.cc b/chromium/storage/common/fileapi/file_system_util.cc
index 3bb9b14f4f4..0472c957d28 100644
--- a/chromium/storage/common/fileapi/file_system_util.cc
+++ b/chromium/storage/common/fileapi/file_system_util.cc
@@ -38,7 +38,7 @@ base::FilePath VirtualPath::BaseName(const base::FilePath& virtual_path) {
 
   // Keep everything after the final separator, but if the pathname is only
   // one character and it's a separator, leave it alone.
-  while (path.size() > 1 && base::FilePath::IsSeparator(path[path.size() - 1]))
+  while (path.size() > 1 && base::FilePath::IsSeparator(path.back()))
     path.resize(path.size() - 1);
   base::FilePath::StringType::size_type last_separator =
       path.find_last_of(base::FilePath::kSeparators);
@@ -57,7 +57,7 @@ base::FilePath VirtualPath::DirName(const base::FilePath& virtual_path) {
   // that this version never cares about '//' or drive-letters even on win32.
 
   // Strip trailing separators.
-  while (path.size() > 1 && base::FilePath::IsSeparator(path[path.size() - 1]))
+  while (path.size() > 1 && base::FilePath::IsSeparator(path.back()))
     path.resize(path.size() - 1);
 
   StringType::size_type last_separator =
@@ -74,7 +74,7 @@ base::FilePath VirtualPath::DirName(const base::FilePath& virtual_path) {
   path.resize(last_separator);
 
   // Strip trailing separators.
-  while (path.size() > 1 && base::FilePath::IsSeparator(path[path.size() - 1]))
+  while (path.size() > 1 && base::FilePath::IsSeparator(path.back()))
     path.resize(path.size() - 1);
 
   if (path.empty())
@@ -138,7 +138,7 @@ base::FilePath::StringType VirtualPath::GetNormalizedFilePath(
 }
 
 bool VirtualPath::IsAbsolute(const base::FilePath::StringType& path) {
-  return path.find(kRoot) == 0;
+  return base::StartsWith(path, kRoot, base::CompareCase::SENSITIVE);
 }
 
 bool VirtualPath::IsRootPath(const base::FilePath& path) {
diff --git a/chromium/storage/storage_browser.gyp b/chromium/storage/storage_browser.gyp
deleted file mode 100644
index f088ac1c7ee..00000000000
--- a/chromium/storage/storage_browser.gyp
+++ /dev/null
@@ -1,226 +0,0 @@
-# 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.
-
-{
-  'variables': {
-    'chromium_code': 1,
-  },
-  'targets': [
-    {
-      # GN version: //storage/browser
-      'target_name': 'storage',
-      'type': '<(component)',
-      'variables': { 'enable_wexit_time_destructors': 1, },
-      'dependencies': [
-        '<(DEPTH)/base/base.gyp:base',
-        '<(DEPTH)/base/base.gyp:base_i18n',
-        '<(DEPTH)/base/third_party/dynamic_annotations/dynamic_annotations.gyp:dynamic_annotations',
-        '<(DEPTH)/net/net.gyp:net',
-        '<(DEPTH)/sql/sql.gyp:sql',
-        '<(DEPTH)/storage/storage_common.gyp:storage_common',
-        '<(DEPTH)/third_party/leveldatabase/leveldatabase.gyp:leveldatabase',
-        '<(DEPTH)/third_party/sqlite/sqlite.gyp:sqlite',
-        '<(DEPTH)/url/url.gyp:url_lib',
-      ],
-      'defines': ['STORAGE_BROWSER_IMPLEMENTATION'],
-      'sources': [
-        'browser/blob/blob_async_builder_host.cc',
-        'browser/blob/blob_async_builder_host.h',
-        'browser/blob/blob_async_transport_request_builder.cc',
-        'browser/blob/blob_async_transport_request_builder.h',
-        'browser/blob/blob_data_builder.cc',
-        'browser/blob/blob_data_builder.h',
-        'browser/blob/blob_data_handle.cc',
-        'browser/blob/blob_data_handle.h',
-        'browser/blob/blob_data_item.cc',
-        'browser/blob/blob_data_item.h',
-        'browser/blob/blob_data_snapshot.cc',
-        'browser/blob/blob_data_snapshot.h',
-        'browser/blob/blob_reader.cc',
-        'browser/blob/blob_reader.h',
-        'browser/blob/blob_storage_context.cc',
-        'browser/blob/blob_storage_context.h',
-        'browser/blob/blob_storage_registry.cc',
-        'browser/blob/blob_storage_registry.h',
-        'browser/blob/blob_url_request_job.cc',
-        'browser/blob/blob_url_request_job.h',
-        'browser/blob/blob_url_request_job_factory.cc',
-        'browser/blob/blob_url_request_job_factory.h',
-        'browser/blob/internal_blob_data.cc',
-        'browser/blob/internal_blob_data.h',
-        'browser/blob/scoped_file.cc',
-        'browser/blob/scoped_file.h',
-        'browser/blob/shareable_blob_data_item.cc',
-        'browser/blob/shareable_blob_data_item.h',
-        'browser/blob/shareable_file_reference.cc',
-        'browser/blob/shareable_file_reference.h',
-        'browser/blob/upload_blob_element_reader.h',
-        'browser/blob/upload_blob_element_reader.cc',
-        'browser/blob/view_blob_internals_job.h',
-        'browser/blob/view_blob_internals_job.cc',
-        'browser/blob/view_blob_internals_job.h',
-        'browser/database/database_quota_client.cc',
-        'browser/database/database_quota_client.h',
-        'browser/database/database_tracker.cc',
-        'browser/database/database_tracker.h',
-        'browser/database/database_util.cc',
-        'browser/database/database_util.h',
-        'browser/database/databases_table.cc',
-        'browser/database/databases_table.h',
-        'browser/database/vfs_backend.cc',
-        'browser/database/vfs_backend.h',
-        'browser/fileapi/async_file_util.h',
-        'browser/fileapi/async_file_util_adapter.cc',
-        'browser/fileapi/async_file_util_adapter.h',
-        'browser/fileapi/copy_or_move_file_validator.h',
-        'browser/fileapi/copy_or_move_operation_delegate.cc',
-        'browser/fileapi/copy_or_move_operation_delegate.h',
-        'browser/fileapi/dragged_file_util.cc',
-        'browser/fileapi/dragged_file_util.h',
-        'browser/fileapi/external_mount_points.cc',
-        'browser/fileapi/external_mount_points.h',
-        'browser/fileapi/file_observers.h',
-        'browser/fileapi/file_permission_policy.h',
-        'browser/fileapi/file_stream_reader.cc',
-        'browser/fileapi/file_stream_reader.h',
-        'browser/fileapi/file_stream_writer.h',
-        'browser/fileapi/file_system_backend.h',
-        'browser/fileapi/file_system_context.cc',
-        'browser/fileapi/file_system_context.h',
-        'browser/fileapi/file_system_dir_url_request_job.cc',
-        'browser/fileapi/file_system_dir_url_request_job.h',
-        'browser/fileapi/file_system_file_stream_reader.cc',
-        'browser/fileapi/file_system_file_stream_reader.h',
-        'browser/fileapi/file_system_file_util.cc',
-        'browser/fileapi/file_system_file_util.h',
-        'browser/fileapi/file_system_operation.h',
-        'browser/fileapi/file_system_operation_context.cc',
-        'browser/fileapi/file_system_operation_context.h',
-        'browser/fileapi/file_system_operation_impl.cc',
-        'browser/fileapi/file_system_operation_impl.h',
-        'browser/fileapi/file_system_operation_runner.cc',
-        'browser/fileapi/file_system_operation_runner.h',
-        'browser/fileapi/file_system_options.cc',
-        'browser/fileapi/file_system_options.h',
-        'browser/fileapi/file_system_quota_client.cc',
-        'browser/fileapi/file_system_quota_client.h',
-        'browser/fileapi/file_system_quota_util.h',
-        'browser/fileapi/file_system_url.cc',
-        'browser/fileapi/file_system_url.h',
-        'browser/fileapi/file_system_url_request_job.cc',
-        'browser/fileapi/file_system_url_request_job.h',
-        'browser/fileapi/file_system_url_request_job_factory.cc',
-        'browser/fileapi/file_system_url_request_job_factory.h',
-        'browser/fileapi/file_system_usage_cache.cc',
-        'browser/fileapi/file_system_usage_cache.h',
-        'browser/fileapi/file_writer_delegate.cc',
-        'browser/fileapi/file_writer_delegate.h',
-        'browser/fileapi/isolated_context.cc',
-        'browser/fileapi/isolated_context.h',
-        'browser/fileapi/isolated_file_system_backend.cc',
-        'browser/fileapi/isolated_file_system_backend.h',
-        'browser/fileapi/local_file_stream_reader.cc',
-        'browser/fileapi/local_file_stream_reader.h',
-        'browser/fileapi/local_file_stream_writer.cc',
-        'browser/fileapi/local_file_stream_writer.h',
-        'browser/fileapi/local_file_util.cc',
-        'browser/fileapi/local_file_util.h',
-        'browser/fileapi/mount_points.cc',
-        'browser/fileapi/mount_points.h',
-        'browser/fileapi/native_file_util.cc',
-        'browser/fileapi/native_file_util.h',
-        'browser/fileapi/obfuscated_file_util.cc',
-        'browser/fileapi/obfuscated_file_util.h',
-        'browser/fileapi/open_file_system_mode.h',
-        'browser/fileapi/plugin_private_file_system_backend.cc',
-        'browser/fileapi/plugin_private_file_system_backend.h',
-        'browser/fileapi/quota/open_file_handle.cc',
-        'browser/fileapi/quota/open_file_handle.h',
-        'browser/fileapi/quota/open_file_handle_context.cc',
-        'browser/fileapi/quota/open_file_handle_context.h',
-        'browser/fileapi/quota/quota_backend_impl.cc',
-        'browser/fileapi/quota/quota_backend_impl.h',
-        'browser/fileapi/quota/quota_reservation.cc',
-        'browser/fileapi/quota/quota_reservation.h',
-        'browser/fileapi/quota/quota_reservation_buffer.cc',
-        'browser/fileapi/quota/quota_reservation_buffer.h',
-        'browser/fileapi/quota/quota_reservation_manager.cc',
-        'browser/fileapi/quota/quota_reservation_manager.h',
-        'browser/fileapi/recursive_operation_delegate.cc',
-        'browser/fileapi/recursive_operation_delegate.h',
-        'browser/fileapi/remove_operation_delegate.cc',
-        'browser/fileapi/remove_operation_delegate.h',
-        'browser/fileapi/sandbox_directory_database.cc',
-        'browser/fileapi/sandbox_directory_database.h',
-        'browser/fileapi/sandbox_file_stream_writer.cc',
-        'browser/fileapi/sandbox_file_stream_writer.h',
-        'browser/fileapi/sandbox_file_system_backend.cc',
-        'browser/fileapi/sandbox_file_system_backend.h',
-        'browser/fileapi/sandbox_file_system_backend_delegate.cc',
-        'browser/fileapi/sandbox_file_system_backend_delegate.h',
-        'browser/fileapi/sandbox_isolated_origin_database.cc',
-        'browser/fileapi/sandbox_isolated_origin_database.h',
-        'browser/fileapi/sandbox_origin_database.cc',
-        'browser/fileapi/sandbox_origin_database.h',
-        'browser/fileapi/sandbox_origin_database_interface.cc',
-        'browser/fileapi/sandbox_origin_database_interface.h',
-        'browser/fileapi/sandbox_prioritized_origin_database.cc',
-        'browser/fileapi/sandbox_prioritized_origin_database.h',
-        'browser/fileapi/sandbox_quota_observer.cc',
-        'browser/fileapi/sandbox_quota_observer.h',
-        'browser/fileapi/task_runner_bound_observer_list.h',
-        'browser/fileapi/timed_task_helper.cc',
-        'browser/fileapi/timed_task_helper.h',
-        'browser/fileapi/transient_file_util.cc',
-        'browser/fileapi/transient_file_util.h',
-        'browser/quota/client_usage_tracker.cc',
-        'browser/quota/client_usage_tracker.h',
-        'browser/quota/quota_callbacks.h',
-        'browser/quota/quota_client.h',
-        'browser/quota/quota_database.cc',
-        'browser/quota/quota_database.h',
-        'browser/quota/quota_manager.cc',
-        'browser/quota/quota_manager.h',
-        'browser/quota/quota_manager_proxy.cc',
-        'browser/quota/quota_manager_proxy.h',
-        'browser/quota/quota_task.cc',
-        'browser/quota/quota_task.h',
-        'browser/quota/quota_temporary_storage_evictor.cc',
-        'browser/quota/quota_temporary_storage_evictor.h',
-        'browser/quota/special_storage_policy.cc',
-        'browser/quota/special_storage_policy.h',
-        'browser/quota/storage_monitor.cc',
-        'browser/quota/storage_monitor.h',
-        'browser/quota/storage_observer.cc',
-        'browser/quota/storage_observer.h',
-        'browser/quota/usage_tracker.cc',
-        'browser/quota/usage_tracker.h',
-        'browser/storage_browser_export.h',
-      ],
-      # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
-      'msvs_disabled_warnings': [ 4267, ],
-
-      'conditions': [
-        ['chrome_multiple_dll!=1', {
-          'dependencies': [
-            '<(DEPTH)/third_party/WebKit/public/blink.gyp:blink',
-          ],
-        }],
-      ],
-    },
-    {
-      # GN version: //storage/browser:dump_file_system
-      'target_name': 'dump_file_system',
-      'type': 'executable',
-      'sources': [
-        'browser/fileapi/dump_file_system.cc',
-      ],
-      'dependencies': [
-        '<(DEPTH)/base/base.gyp:base',
-        '<(DEPTH)/storage/storage_common.gyp:storage_common',
-        'storage',
-      ],
-    },
-  ],
-}
diff --git a/chromium/storage/storage_common.gyp b/chromium/storage/storage_common.gyp
deleted file mode 100644
index 305a61258e1..00000000000
--- a/chromium/storage/storage_common.gyp
+++ /dev/null
@@ -1,51 +0,0 @@
-# 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.
-
-{
-  'variables': {
-    'chromium_code': 1,
-  },
-  'targets': [
-    {
-      # GN version: //storage/common
-      'target_name': 'storage_common',
-      'type': '<(component)',
-      'variables': { 'enable_wexit_time_destructors': 1, },
-      'dependencies': [
-        '<(DEPTH)/base/base.gyp:base',
-        '<(DEPTH)/base/third_party/dynamic_annotations/dynamic_annotations.gyp:dynamic_annotations',
-        '<(DEPTH)/net/net.gyp:net',
-        '<(DEPTH)/url/url.gyp:url_lib',
-      ],
-      'defines': ['STORAGE_COMMON_IMPLEMENTATION'],
-      'sources': [
-        'common/blob_storage/blob_item_bytes_request.cc',
-        'common/blob_storage/blob_item_bytes_request.h',
-        'common/blob_storage/blob_item_bytes_response.cc',
-        'common/blob_storage/blob_item_bytes_response.h',
-        'common/blob_storage/blob_storage_constants.h',
-        'common/data_element.cc',
-        'common/data_element.h',
-        'common/database/database_connections.cc',
-        'common/database/database_connections.h',
-        'common/database/database_identifier.cc',
-        'common/database/database_identifier.h',
-        'common/fileapi/directory_entry.cc',
-        'common/fileapi/directory_entry.h',
-        'common/fileapi/file_system_info.cc',
-        'common/fileapi/file_system_info.h',
-        'common/fileapi/file_system_mount_option.h',
-        'common/fileapi/file_system_types.h',
-        'common/fileapi/file_system_util.cc',
-        'common/fileapi/file_system_util.h',
-        'common/quota/quota_status_code.cc',
-        'common/quota/quota_status_code.h',
-        'common/quota/quota_types.h',
-        'common/storage_common_export.h',
-      ],
-      # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
-      'msvs_disabled_warnings': [ 4267, ],
-    },
-  ],
-}