Remove some uses of stl_util's STLDeleteContainerPointers.

content/browser/appcache/appcache_update_job_unittest.cc

 // Copyright 2014 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/appcache/appcache_update_job.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 3029 matching lines @@
 
   void UpdateFinishedUnwound() {
     EXPECT_EQ(AppCacheGroup::IDLE, group_->update_status());
     EXPECT_TRUE(group_->update_job() == NULL);
     if (do_checks_after_update_finished_)
       VerifyExpectations();
 
     // Clean up everything that was created on the IO thread.
     protect_newest_cache_ = NULL;
     group_ = NULL;
-    base::STLDeleteContainerPointers(hosts_.begin(), hosts_.end());
-    base::STLDeleteContainerPointers(frontends_.begin(), frontends_.end());
+    hosts_.clear();
+    frontends_.clear();
     response_infos_.clear();
     service_.reset(NULL);
 
     event_->Signal();
   }
 
   void MakeService() {
     service_.reset(new MockAppCacheService());
     service_->set_request_context(io_thread_->request_context());
   }
@@ skipping 18 matching lines @@
 
     // Specific tests that expect a newer time should set
     // expect_full_update_time_newer_than_ which causes this
     // equality expectation to be ignored.
     expect_full_update_time_equal_to_ = cache->update_time();
 
     return cache;
   }
 
   AppCacheHost* MakeHost(int host_id, AppCacheFrontend* frontend) {
-    AppCacheHost* host = new AppCacheHost(host_id, frontend, service_.get());
-    hosts_.push_back(host);
-    return host;
+    hosts_.push_back(
+        base::MakeUnique<AppCacheHost>(host_id, frontend, service_.get()));
+    return hosts_.back().get();
   }
 
   AppCacheResponseInfo* MakeAppCacheResponseInfo(
       const GURL& manifest_url,
       int64_t response_id,
       const std::string& raw_headers) {
     net::HttpResponseInfo* http_info = new net::HttpResponseInfo();
     http_info->headers = new net::HttpResponseHeaders(raw_headers);
     scoped_refptr<AppCacheResponseInfo> info(
         new AppCacheResponseInfo(service_->storage(), manifest_url,
                                  response_id, http_info, 0));
     response_infos_.push_back(info);
     return info.get();
   }
 
   MockFrontend* MakeMockFrontend() {
-    MockFrontend* frontend = new MockFrontend();
-    frontends_.push_back(frontend);
-    return frontend;
+    frontends_.push_back(base::MakeUnique<MockFrontend>());
+    return frontends_.back().get();
   }
 
   // Verifies conditions about the group and notifications after an update
   // has finished. Cannot verify update job internals as update is deleted.
   void VerifyExpectations() {
     RetryRequestTestJob::Verify();
     HttpHeadersRequestTestJob::Verify();
 
     EXPECT_EQ(expect_group_obsolete_, group_->is_obsolete());
     EXPECT_EQ(expect_group_is_being_deleted_ || expect_eviction_,
@@ skipping 64 matching lines @@
               EXPECT_NE(old_entry->response_id(), it->second.response_id());
           }
         }
       }
     } else {
       EXPECT_TRUE(group_->newest_complete_cache() == NULL);
     }
 
     // Check expected events.
     for (size_t i = 0; i < frontends_.size(); ++i) {
-      MockFrontend* frontend = frontends_[i];
+      MockFrontend* frontend = frontends_[i].get();
 
       MockFrontend::RaisedEvents& expected_events = frontend->expected_events_;
       MockFrontend::RaisedEvents& actual_events = frontend->raised_events_;
       EXPECT_EQ(expected_events.size(), actual_events.size());
 
       // Check each expected event.
       for (size_t j = 0;
            j < expected_events.size() && j < actual_events.size(); ++j) {
         EXPECT_EQ(expected_events[j].second, actual_events[j].second);
 
@@ skipping 216 matching lines @@
 
   std::unique_ptr<MockAppCacheService> service_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> protect_newest_cache_;
   std::unique_ptr<base::WaitableEvent> event_;
 
   std::unique_ptr<AppCacheResponseWriter> response_writer_;
 
   // Hosts used by an async test that need to live until update job finishes.
   // Otherwise, test can put host on the stack instead of here.
-  std::vector<AppCacheHost*> hosts_;
+  std::vector<std::unique_ptr<AppCacheHost>> hosts_;
 
   // Response infos used by an async test that need to live until update job
   // finishes.
   std::vector<scoped_refptr<AppCacheResponseInfo> > response_infos_;
 
   // Flag indicating if test cares to verify the update after update finishes.
   bool do_checks_after_update_finished_;
   bool expect_group_obsolete_;
   bool expect_group_has_cache_;
   bool expect_group_is_being_deleted_;
   bool expect_evictable_error_;
   bool expect_eviction_;
   base::Time expect_full_update_time_newer_than_;
   base::Time expect_full_update_time_equal_to_;
   AppCache* expect_old_cache_;
   AppCache* expect_newest_cache_;
   bool expect_non_null_update_time_;
-  std::vector<MockFrontend*> frontends_;  // to check expected events
+  std::vector<std::unique_ptr<MockFrontend>>
+      frontends_;  // to check expected events
   TestedManifest tested_manifest_;
   const char* tested_manifest_path_override_;
   AppCache::EntryMap expect_extra_entries_;
   std::map<GURL, int64_t> expect_response_ids_;
 };
 
 TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), GURL("http://manifesturl.com"),
@@ skipping 263 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace content