Remove stl_util's deletion functions from storage/.

storage/browser/blob/blob_reader.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "storage/browser/blob/blob_reader.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
 
 #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"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
 #include "storage/browser/fileapi/file_stream_reader.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_url.h"
@@ skipping 40 matching lines @@
     : file_stream_provider_(std::move(file_stream_provider)),
       file_task_runner_(file_task_runner),
       net_error_(net::OK),
       weak_factory_(this) {
   if (blob_handle && !blob_handle->IsBroken()) {
     blob_handle_.reset(new BlobDataHandle(*blob_handle));
   }
 }
 
 BlobReader::~BlobReader() {
-  base::STLDeleteValues(&index_to_reader_);
 }
 
 BlobReader::Status BlobReader::CalculateSize(
     const net::CompletionCallback& done) {
   DCHECK(!total_size_calculated_);
   DCHECK(size_callback_.is_null());
   if (!blob_handle_.get() || blob_handle_->IsBroken()) {
     return ReportError(net::ERR_FILE_NOT_FOUND);
   }
   if (blob_handle_->IsBeingBuilt()) {
@@ skipping 523 matching lines @@
 
 FileStreamReader* BlobReader::GetOrCreateFileReaderAtIndex(size_t index) {
   const auto& items = blob_data_->items();
   DCHECK_LT(index, items.size());
   const BlobDataItem& item = *items.at(index);
   if (!IsFileType(item.type()))
     return nullptr;
   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;
 }
 
 std::unique_ptr<FileStreamReader> BlobReader::CreateFileStreamReader(
     const BlobDataItem& item,
     uint64_t additional_offset) {
   DCHECK(IsFileType(item.type()));
 
   switch (item.type()) {
     case DataElement::TYPE_FILE:
@@ skipping 15 matching lines @@
       break;
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 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();
-  }
+  DCHECK_EQ(index, current_item_index_);

[Avi (use Gerrit), 2016/10/02 00:14:19]

OK, what is going on here?

This function says "set the file reader at this index" but it **ignored** the
index passed in, and always used the current_item_index_. I'm checking that
they're equal out of paranoia, but this interface makes little sense to me.

[danakj, 2016/10/03 22:51:49]

Good question. +dmurph who wrote this.

[dmurph, 2016/10/04 19:23:24]

Ah, sorry for this. You can remove the DCHECK, this is only ever called w/
current_item_index_ and it should have been changed.

+  if (reader)
+    index_to_reader_[index] = std::move(reader);
+  else
+    index_to_reader_.erase(index);
 }
 
 }  // namespace storage