Remove ScopedVector from ios/.

ios/web/net/request_tracker_impl.mm

 // 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.
 
 #import "ios/web/net/request_tracker_impl.h"
 
 #include <pthread.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind_helpers.h"
 #include "base/containers/hash_tables.h"
 #include "base/location.h"
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/synchronization/lock.h"
 #import "ios/net/clients/crn_forwarding_network_client.h"
 #import "ios/net/clients/crn_forwarding_network_client_factory.h"
 #include "ios/web/history_state_util.h"
 #import "ios/web/net/crw_request_tracker_delegate.h"
 #include "ios/web/public/browser_state.h"
 #include "ios/web/public/certificate_policy_cache.h"
 #include "ios/web/public/ssl_status.h"
@@ skipping 452 matching lines @@
   DCHECK_EQ(is_for_static_file_requests_, request->url().SchemeIsFile());
 
   if (new_estimate_round_) {
     // Starting a new estimate round. Ignore the previous requests for the
     // calculation.
     counts_by_request_.clear();
     estimate_start_index_ = counts_.size();
     new_estimate_round_ = false;
   }
   const GURL& url = request->original_url();
-  TrackerCounts* counts = new TrackerCounts(
-      GURLByRemovingRefFromGURL(url), request);
-  counts_.push_back(counts);
-  counts_by_request_[request] = counts;
+  auto counts =
+      base::MakeUnique<TrackerCounts>(GURLByRemovingRefFromGURL(url), request);
+  counts_by_request_[request] = counts.get();
+  counts_.push_back(std::move(counts));
   if (page_url_.SchemeIsCryptographic() && !url.SchemeIsCryptographic())
     has_mixed_content_ = true;
   Notify();
 }
 
 void RequestTrackerImpl::CaptureHeaders(net::URLRequest* request) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   if (is_closing_)
     return;
 
@@ skipping 276 matching lines @@
   if (is_closing_)
     return;
 
   if (counts_.empty())
     return;  // Nothing yet to notify.
 
   if (!page_url_.SchemeIsCryptographic())
     return;
 
   const GURL page_origin = page_url_.GetOrigin();
-  ScopedVector<TrackerCounts>::iterator it;
-  for (it = counts_.begin(); it != counts_.end(); ++it) {
-    if (!(*it)->ssl_info.is_valid())
+  for (const auto& tracker_count : counts_) {
+    if (!tracker_count->ssl_info.is_valid())
       continue;  // No SSL info at this point in time on this tracker.
 
-    GURL request_origin = (*it)->url.GetOrigin();
+    GURL request_origin = tracker_count->url.GetOrigin();
     if (request_origin != page_origin)
       continue;  // Not interesting in the context of the page.
 
-    base::scoped_nsobject<CRWSSLCarrier> carrier(
-        [[CRWSSLCarrier alloc] initWithTracker:this counts:*it]);
+    base::scoped_nsobject<CRWSSLCarrier> carrier([[CRWSSLCarrier alloc]
+        initWithTracker:this
+                 counts:tracker_count.get()]);
     web::WebThread::PostTask(
         web::WebThread::UI, FROM_HERE,
         base::Bind(&RequestTrackerImpl::NotifyUpdatedSSLStatus, this, carrier));
     break;
   }
 }
 
 void RequestTrackerImpl::NotifyResponseHeaders(
     net::HttpResponseHeaders* headers,
     const GURL& request_url) {
@@ skipping 109 matching lines @@
       CancelRequestForCounts(counts);
       break;
   }
 }
 
 void RequestTrackerImpl::ReevaluateCallbacksForAllCounts() {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   if (is_closing_)
     return;
 
-  ScopedVector<TrackerCounts>::iterator it;
-  for (it = counts_.begin(); it != counts_.end(); ++it) {
+  for (const auto& tracker_count : counts_) {
     // Check if the value hasn't changed via a user action.
-    if ((*it)->ssl_judgment == CertPolicy::UNKNOWN)
-      EvaluateSSLCallbackForCounts(*it);
+    if (tracker_count->ssl_judgment == CertPolicy::UNKNOWN)
+      EvaluateSSLCallbackForCounts(tracker_count.get());
 
-    CertPolicy::Judgment judgment = (*it)->ssl_judgment;
+    CertPolicy::Judgment judgment = tracker_count->ssl_judgment;
     if (judgment == CertPolicy::ALLOWED)
       continue;
 
     // SSL errors on subrequests are simply ignored. The call to
     // EvaluateSSLCallbackForCounts() cancelled the request and nothing will
     // restart it.
-    if ((*it)->is_subrequest)
+    if (tracker_count->is_subrequest)
       continue;
 
     if (!current_ssl_error_) {
       // For the UNKNOWN and DENIED state the information should be pushed to
       // the delegate. But only one at a time.
-      current_ssl_error_ = (*it);
+      current_ssl_error_ = tracker_count.get();
       base::scoped_nsobject<CRWSSLCarrier> carrier([[CRWSSLCarrier alloc]
           initWithTracker:this counts:current_ssl_error_]);
       web::WebThread::PostTask(
           web::WebThread::UI, FROM_HERE,
           base::Bind(&RequestTrackerImpl::NotifyPresentSSLError, this, carrier,
                      judgment == CertPolicy::UNKNOWN));
     }
   }
 }
 
 void RequestTrackerImpl::CancelRequestForCounts(TrackerCounts* counts) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   // Cancel the request.
   counts->done = true;
   counts_by_request_.erase(counts->request);
   counts->ssl_callback.Run(NO);
   counts->ssl_callback = base::Bind(&DoNothing);
   Notify();
 }
 
 PageCounts RequestTrackerImpl::pageCounts() {
   DCHECK_GE(counts_.size(), estimate_start_index_);
 
   PageCounts page_counts;
 
-  ScopedVector<TrackerCounts>::iterator it;
-  for (it = counts_.begin() + estimate_start_index_;
-       it != counts_.end(); ++it) {
-    if ((*it)->done) {
-      uint64_t size = (*it)->processed;
+  for (const auto& tracker_count : counts_) {
+    if (tracker_count->done) {
+      uint64_t size = tracker_count->processed;
       page_counts.finished += 1;
       page_counts.finished_bytes += size;
       if (page_counts.largest_byte_size_known < size) {
         page_counts.largest_byte_size_known = size;
       }
     } else {
       page_counts.unfinished += 1;
-      if ((*it)->expected_length) {
-        uint64_t size = (*it)->expected_length;
-        page_counts.unfinished_estimate_bytes_done += (*it)->processed;
+      if (tracker_count->expected_length) {
+        uint64_t size = tracker_count->expected_length;
+        page_counts.unfinished_estimate_bytes_done += tracker_count->processed;
         page_counts.unfinished_estimated_bytes_left += size;
         if (page_counts.largest_byte_size_known < size) {
           page_counts.largest_byte_size_known = size;
         }
       } else {
         page_counts.unfinished_no_estimate += 1;
-        page_counts.unfinished_no_estimate_bytes_done += (*it)->processed;
+        page_counts.unfinished_no_estimate_bytes_done +=
+            tracker_count->processed;
       }
     }
   }
 
   return page_counts;
 }
 
 float RequestTrackerImpl::EstimatedProgress() {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
 
@@ skipping 67 matching lines @@
   return previous_estimate_;
 }
 
 void RequestTrackerImpl::RecomputeMixedContent(
     const TrackerCounts* split_position) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   // Check if the mixed content before trimming was correct.
   if (page_url_.SchemeIsCryptographic() && has_mixed_content_) {
     bool old_url_has_mixed_content = false;
     const GURL origin = page_url_.GetOrigin();
-    ScopedVector<TrackerCounts>::iterator it = counts_.begin();
-    while (it != counts_.end() && *it != split_position) {
+    auto it = counts_.begin();
+    while (it != counts_.end() && it->get() != split_position) {
       if (!(*it)->url.SchemeIsCryptographic() &&
           origin == (*it)->first_party_for_cookies_origin) {
         old_url_has_mixed_content = true;
         break;
       }
       ++it;
     }
     if (!old_url_has_mixed_content) {
       // We marked the previous page with incorrect data about its mixed
       // content. Turns out that the elements that triggered that condition
       // where in fact in a subsequent page. Duh.
       // Resend a notification for the |page_url_| informing the upper layer
       // that the mixed content was a red herring.
       has_mixed_content_ = false;
       SSLNotify();
     }
   }
 }
 
 void RequestTrackerImpl::RecomputeCertificatePolicy(
     const TrackerCounts* splitPosition) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   // Clear the judgments for the old URL.
   web::WebThread::PostTask(
       web::WebThread::UI, FROM_HERE,
       base::Bind(&RequestTrackerImpl::NotifyClearCertificates, this));
   // Report judgements for the new URL.
-  ScopedVector<TrackerCounts>::const_reverse_iterator it;
-  for (it = counts_.rbegin(); it != counts_.rend(); ++it) {
-    TrackerCounts* counts = *it;
+  for (auto it = counts_.rbegin(); it != counts_.rend(); ++it) {
+    TrackerCounts* counts = it->get();
     if (counts->allowed_by_user) {
       std::string host = counts->url.host();
       web::WebThread::PostTask(
           web::WebThread::UI, FROM_HERE,
           base::Bind(&RequestTrackerImpl::NotifyCertificateUsed, this,
                      base::RetainedRef(counts->ssl_info.cert), host,
                      counts->ssl_info.cert_status));
     }
     if (counts == splitPosition)
       break;
@@ skipping 11 matching lines @@
 }
 
 void RequestTrackerImpl::TrimToURL(const GURL& full_url, id user_info) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
 
   GURL url = GURLByRemovingRefFromGURL(full_url);
 
   // Locate the request with this url, if present.
   bool new_url_has_mixed_content = false;
   bool url_scheme_is_secure = url.SchemeIsCryptographic();
-  ScopedVector<TrackerCounts>::const_reverse_iterator rit = counts_.rbegin();
+  auto rit = counts_.rbegin();
   while (rit != counts_.rend() && (*rit)->url != url) {
     if (url_scheme_is_secure && !(*rit)->url.SchemeIsCryptographic() &&
         (*rit)->first_party_for_cookies_origin == url.GetOrigin()) {
       new_url_has_mixed_content = true;
     }
     ++rit;
   }
 
   // |split_position| will be set to the count for the passed url if it exists.
   TrackerCounts* split_position = NULL;
   if (rit != counts_.rend()) {
-    split_position = (*rit);
+    split_position = rit->get();
   } else {
     // The URL was not found, everything will be trimmed. The mixed content
     // calculation is invalid.
     new_url_has_mixed_content = false;
 
     // In the case of a page loaded via a HTML5 manifest there is no page
     // boundary to be found. However the latest count is a request for a
     // manifest. This tries to detect this peculiar case.
     // This is important as if this request for the manifest is on the same
     // domain as the page itself this will allow retrieval of the SSL
     // information.
     if (url_scheme_is_secure && counts_.size()) {
-      TrackerCounts* back = counts_.back();
+      TrackerCounts* back = counts_.back().get();
       const GURL& back_url = back->url;
       if (back_url.SchemeIsCryptographic() &&
           back_url.GetOrigin() == url.GetOrigin() && !back->is_subrequest) {
         split_position = back;
       }
     }
   }
   RecomputeMixedContent(split_position);
   RecomputeCertificatePolicy(split_position);
 
   // Trim up to that element.
-  ScopedVector<TrackerCounts>::iterator it = counts_.begin();
-  while (it != counts_.end() && *it != split_position) {
+  auto it = counts_.begin();
+  while (it != counts_.end() && it->get() != split_position) {
     if (!(*it)->done) {
       // This is for an unfinished request on a previous page. We do not care
       // about those anymore. Cancel the request.
       if ((*it)->ssl_judgment == CertPolicy::UNKNOWN)
-        CancelRequestForCounts(*it);
+        CancelRequestForCounts(it->get());
       counts_by_request_.erase((*it)->request);
     }
     it = counts_.erase(it);
   }
 
   has_mixed_content_ = new_url_has_mixed_content;
   page_url_ = url;
   user_info_.reset(user_info);
   estimate_start_index_ = 0;
   is_loading_ = true;
@@ skipping 25 matching lines @@
     return;
   web::WebThread::PostTask(thread, FROM_HERE, task);
 }
 
 #pragma mark Other internal methods.
 
 NSString* RequestTrackerImpl::UnsafeDescription() {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
 
   NSMutableArray* urls = [NSMutableArray array];
-  ScopedVector<TrackerCounts>::iterator it;
-  for (it = counts_.begin(); it != counts_.end(); ++it)
-    [urls addObject:(*it)->Description()];
+  for (const auto& tracker_count : counts_)
+    [urls addObject:tracker_count->Description()];
 
   return [NSString stringWithFormat:@"RequestGroupID %@\n%@\n%@",
                                     request_group_id_.get(),
                                     net::NSURLWithGURL(page_url_),
                                     [urls componentsJoinedByString:@"\n"]];
 }
 
 void RequestTrackerImpl::CancelRequests() {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   std::set<net::URLRequest*>::iterator it;
   // TODO(droger): When canceling the request, we should in theory make sure
   // that the NSURLProtocol client method |didFailWithError| is called,
   // otherwise the iOS system may wait indefinitely for the request to complete.
   // However, as we currently only cancel the requests when closing a tab, the
   // requests are all canceled by the system shortly after and nothing bad
   // happens.
   for (it = live_requests_.begin(); it != live_requests_.end(); ++it)
     (*it)->Cancel();
 
   live_requests_.clear();
 }
 
 void RequestTrackerImpl::SetCertificatePolicyCacheForTest(
     web::CertificatePolicyCache* cache) {
   policy_cache_ = cache;
 }
 
 }  // namespace web