Switch remaining functions from SchemeIsSecure() to SchemeIsCryptographic().

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.
 
 #include "ios/web/net/request_tracker_impl.h"
 
 #include <pthread.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/location.h"
@@ skipping 270 matching lines @@
     // TODO(noyau): In iOS there is no notion of resource type. The insecure
     // content could be an image (DISPLAYED_INSECURE_CONTENT) or a script
     // (RAN_INSECURE_CONTENT). The status of the page is different for both, but
     // there is not enough information from UIWebView to differentiate the two
     // cases.
     status_.content_status = web::SSLStatus::DISPLAYED_INSECURE_CONTENT;
   } else {
     status_.content_status = web::SSLStatus::NORMAL_CONTENT;
   }
 
-  if (!url_.SchemeIsSecure()) {
+  if (!url_.SchemeIsCryptographic()) {
     // Should not happen as the sslInfo is valid.
     NOTREACHED();
     status_.security_style = web::SECURITY_STYLE_UNAUTHENTICATED;
   } else if (net::IsCertStatusError(status_.cert_status) &&
              !net::IsCertStatusMinorError(status_.cert_status)) {
     // Minor errors don't lower the security style to
     // SECURITY_STYLE_AUTHENTICATION_BROKEN.
     status_.security_style = web::SECURITY_STYLE_AUTHENTICATION_BROKEN;
   } else {
     // This page is secure.
@@ skipping 186 matching lines @@
     // 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;
-  if (page_url_.SchemeIsSecure() && !url.SchemeIsSecure())
+  if (page_url_.SchemeIsCryptographic() && !url.SchemeIsCryptographic())
     has_mixed_content_ = true;
   Notify();
 }
 
 void RequestTrackerImpl::CaptureHeaders(net::URLRequest* request) {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::IO);
   if (is_closing_)
     return;
 
   if (!request->response_headers())
@@ skipping 295 matching lines @@
 }
 
 void RequestTrackerImpl::SSLNotify() {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::IO);
   if (is_closing_)
     return;
 
   if (!counts_.size())
     return;  // Nothing yet to notify.
 
-  if (!page_url_.SchemeIsSecure())
+  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())
       continue;  // No SSL info at this point in time on this tracker.
 
     GURL request_origin = (*it)->url.GetOrigin();
     if (request_origin != page_origin)
@@ skipping 271 matching lines @@
     previous_estimate_ += maxBump;
   }
 
   return previous_estimate_;
 }
 
 void RequestTrackerImpl::RecomputeMixedContent(
     const TrackerCounts* split_position) {
   DCHECK_CURRENTLY_ON_WEB_THREAD(web::WebThread::IO);
   // Check if the mixed content before trimming was correct.
-  if (page_url_.SchemeIsSecure() && has_mixed_content_) {
+  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) {
-      if (!(*it)->url.SchemeIsSecure() &&
+      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.
@@ skipping 39 matching lines @@
   }
 }
 
 void RequestTrackerImpl::TrimToURL(const GURL& full_url, id user_info) {
   DCHECK_CURRENTLY_ON_WEB_THREAD(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.SchemeIsSecure();
+  bool url_scheme_is_secure = url.SchemeIsCryptographic();
   ScopedVector<TrackerCounts>::const_reverse_iterator rit = counts_.rbegin();
   while (rit != counts_.rend() && (*rit)->url != url) {
-    if (url_scheme_is_secure && !(*rit)->url.SchemeIsSecure() &&
+    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);
   } 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();
       const GURL& back_url = back->url;
-      if (back_url.SchemeIsSecure() &&
-          back_url.GetOrigin() == url.GetOrigin() &&
-          !back->is_subrequest) {
+      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) {
@@ skipping 87 matching lines @@
         }));
   }
 }
 
 void RequestTrackerImpl::SetCertificatePolicyCacheForTest(
     web::CertificatePolicyCache* cache) {
   policy_cache_ = cache;
 }
 
 }  // namespace web