Remove stl_util's STLDeleteContainerPairSecondPointers.

content/child/resource_dispatcher_unittest.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/resource_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
-#include "base/stl_util.h"
 #include "content/child/request_extra_data.h"
 #include "content/common/appcache_interfaces.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/child/fixed_received_data.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/child/resource_dispatcher_delegate.h"
 #include "content/public/common/content_features.h"
@@ skipping 108 matching lines @@
 };
 
 // Sets up the message sender override for the unit test.
 class ResourceDispatcherTest : public testing::Test, public IPC::Sender {
  public:
   ResourceDispatcherTest()
       : dispatcher_(new ResourceDispatcher(this, message_loop_.task_runner())) {
   }
 
   ~ResourceDispatcherTest() override {
-    base::STLDeleteContainerPairSecondPointers(shared_memory_map_.begin(),
-                                               shared_memory_map_.end());
+    shared_memory_map_.clear();
     dispatcher_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   // Emulates IPC send operations (IPC::Sender) by adding
   // pending messages to the queue.
   bool Send(IPC::Message* msg) override {
     message_queue_.push_back(IPC::Message(*msg));
     delete msg;
     return true;
@@ skipping 93 matching lines @@
     head.headers = new net::HttpResponseHeaders(raw_headers);
     head.mime_type = kTestPageMimeType;
     head.charset = kTestPageCharset;
     EXPECT_EQ(true, dispatcher_->OnMessageReceived(
                         ResourceMsg_ReceivedResponse(request_id, head)));
   }
 
   void NotifySetDataBuffer(int request_id, size_t buffer_size) {
     base::SharedMemory* shared_memory = new base::SharedMemory();
     ASSERT_FALSE(shared_memory_map_[request_id]);
-    shared_memory_map_[request_id] = shared_memory;
+    shared_memory_map_[request_id] = base::WrapUnique(shared_memory);
     EXPECT_TRUE(shared_memory->CreateAndMapAnonymous(buffer_size));
 
     base::SharedMemoryHandle duplicate_handle;
     EXPECT_TRUE(shared_memory->ShareToProcess(base::GetCurrentProcessHandle(),
                                               &duplicate_handle));
     EXPECT_TRUE(dispatcher_->OnMessageReceived(ResourceMsg_SetDataBuffer(
         request_id, duplicate_handle, shared_memory->requested_size(), 0)));
   }
 
   void NotifyDataReceived(int request_id, const std::string& data) {
@@ skipping 58 matching lines @@
         new TestRequestPeer(dispatcher(), peer_context));
     int request_id = dispatcher()->StartAsync(
         std::move(request), 0, nullptr, GURL(), std::move(peer),
         blink::WebURLRequest::LoadingIPCType::ChromeIPC, nullptr);
     peer_context->request_id = request_id;
     return request_id;
   }
 
  private:
   // Map of request IDs to shared memory.
-  std::map<int, base::SharedMemory*> shared_memory_map_;
+  std::map<int, std::unique_ptr<base::SharedMemory>> shared_memory_map_;
 
   std::vector<IPC::Message> message_queue_;
   base::MessageLoop message_loop_;
   std::unique_ptr<ResourceDispatcher> dispatcher_;
 };
 
 // Does a simple request and tests that the correct data is received.  Simulates
 // two reads.
 TEST_F(ResourceDispatcherTest, RoundTrip) {
   // Number of bytes received in the first read.
@@ skipping 581 matching lines @@
   ResourceResponseHead response_head;
 
   PerformTest(response_head);
 
   EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
   EXPECT_EQ(base::TimeTicks(),
             response_info().load_timing.connect_timing.dns_start);
 }
 
 }  // namespace content