Remove obsolete methods from CRWRequestTrackerDelegate protocol.

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>
 
@@ skipping 204 matching lines @@
 // Designated initializer.
 - (id)initWithTracker:(web::RequestTrackerImpl*)tracker
                counts:(const TrackerCounts*)counts;
 // URL of the request.
 - (const GURL&)url;
 // Returns a SSLStatus representing the state of the page. This assumes the
 // target carrier is the main page request.
 - (const web::SSLStatus&)sslStatus;
 // Returns a SSLInfo with a reference to the certificate and SSL information.
 - (const net::SSLInfo&)sslInfo;
-// Callback method to allow or deny the request from going through.
-- (void)errorCallback:(BOOL)flag;
 // Internal method used to build the SSLStatus object. Called from the
 // initializer to make sure it is invoked on the network thread.
 - (void)buildSSLStatus;
 @end
 
 @implementation CRWSSLCarrier
 
 - (id)initWithTracker:(web::RequestTrackerImpl*)tracker
                counts:(const TrackerCounts*)counts {
   self = [super init];
@@ skipping 11 matching lines @@
 }
 
 - (const net::SSLInfo&)sslInfo {
   return sslInfo_;
 }
 
 - (const web::SSLStatus&)sslStatus {
   return status_;
 }
 
-- (void)errorCallback:(BOOL)flag {
-  base::scoped_nsobject<CRWSSLCarrier> scoped(self);
-  web::WebThread::PostTask(web::WebThread::IO, FROM_HERE,
-                           base::Bind(&web::RequestTrackerImpl::ErrorCallback,
-                                      tracker_, scoped, flag));
-}
-
 - (void)buildSSLStatus {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   if (!sslInfo_.is_valid())
     return;
 
   status_.certificate = sslInfo_.cert;
 
   status_.cert_status = sslInfo_.cert_status;
   if (status_.cert_status & net::CERT_STATUS_COMMON_NAME_INVALID) {
     // CAs issue certificates for intranet hosts to everyone.  Therefore, we
@@ skipping 193 matching lines @@
 }
 
 net::URLRequestContext* RequestTrackerImpl::GetRequestContext() {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   return request_context_getter_->GetURLRequestContext();
 }
 
 void RequestTrackerImpl::StartRequest(net::URLRequest* request) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   DCHECK(!counts_by_request_.count(request));
-  DCHECK_EQ(is_for_static_file_requests_, request->url().SchemeIsFile());
+  DCHECK(!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();
   auto counts =
@@ skipping 123 matching lines @@
     DCHECK(!counts->done);
     // Store the ssl error.
     counts->ssl_info = ssl_info;
     counts->ssl_callback = should_continue;
     counts->ssl_judgment =
         recoverable ? CertPolicy::UNKNOWN : CertPolicy::DENIED;
     ReevaluateCallbacksForAllCounts();
   }
 }
 
-void RequestTrackerImpl::ErrorCallback(CRWSSLCarrier* carrier, bool allow) {
-  DCHECK_CURRENTLY_ON(web::WebThread::IO);
-  DCHECK(policy_cache_);
-
-  if (allow) {
-    policy_cache_->AllowCertForHost([carrier sslInfo].cert.get(),
-                                    [carrier url].host(),
-                                    [carrier sslInfo].cert_status);
-    ReevaluateCallbacksForAllCounts();
-  }
-  current_ssl_error_ = NULL;
-}
-
 #pragma mark Client utility methods.
 
 void RequestTrackerImpl::PostUITaskIfOpen(const base::Closure& task) {
   PostTask(task, web::WebThread::UI);
 }
 
 // static
 void RequestTrackerImpl::PostUITaskIfOpen(
     const base::WeakPtr<RequestTracker> tracker,
     const base::Closure& task) {
@@ skipping 16 matching lines @@
 #pragma mark Private Object Lifecycle API
 
 RequestTrackerImpl::RequestTrackerImpl(
     NSString* request_group_id,
     net::URLRequestContextGetter* context_getter,
     id<CRWRequestTrackerDelegate> delegate)
     : delegate_(delegate),
       previous_estimate_(0.0f),  // Not active by default.
       estimate_start_index_(0),
       notification_depth_(0),
-      current_ssl_error_(NULL),
       has_mixed_content_(false),
       is_loading_(false),
       new_estimate_round_(true),
-      is_for_static_file_requests_([delegate isForStaticFileRequests]),
       request_context_getter_(context_getter),
       identifier_(++g_next_request_tracker_id),
       request_group_id_([request_group_id copy]),
       is_closing_(false) {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
 }
 
 void RequestTrackerImpl::InitOnIOThread(
     const scoped_refptr<CertificatePolicyCache>& policy_cache) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
@@ skipping 135 matching lines @@
 }
 
 void RequestTrackerImpl::NotifyUpdatedSSLStatus(
     base::scoped_nsobject<CRWSSLCarrier> carrier) {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   [delegate_ updatedSSLStatus:[carrier sslStatus]
                    forPageUrl:[carrier url]
                      userInfo:user_info_];
 }
 
-void RequestTrackerImpl::NotifyPresentSSLError(
-    base::scoped_nsobject<CRWSSLCarrier> carrier,
-    bool recoverable) {
-  DCHECK_CURRENTLY_ON(web::WebThread::UI);
-  [delegate_ presentSSLError:[carrier sslInfo]
-                forSSLStatus:[carrier sslStatus]
-                       onUrl:[carrier url]
-                 recoverable:recoverable
-                    callback:^(BOOL flag) {
-                         [carrier errorCallback:flag && recoverable];
-                    }];
-}
-
 void RequestTrackerImpl::EvaluateSSLCallbackForCounts(TrackerCounts* counts) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   DCHECK(policy_cache_);
 
   // Ignore non-SSL requests.
   if (!counts->ssl_info.is_valid())
     return;
 
   CertPolicy::Judgment judgment =
       policy_cache_->QueryPolicy(counts->ssl_info.cert.get(),
@@ skipping 60 matching lines @@
 
 void RequestTrackerImpl::ReevaluateCallbacksForAllCounts() {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   if (is_closing_)
     return;
 
   for (const auto& tracker_count : counts_) {
     // Check if the value hasn't changed via a user action.
     if (tracker_count->ssl_judgment == CertPolicy::UNKNOWN)
       EvaluateSSLCallbackForCounts(tracker_count.get());
-
-    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 (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_ = 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);
@@ skipping 272 matching lines @@
                                     net::NSURLWithGURL(page_url_),
                                     [urls componentsJoinedByString:@"\n"]];
 }
 
 void RequestTrackerImpl::SetCertificatePolicyCacheForTest(
     web::CertificatePolicyCache* cache) {
   policy_cache_ = cache;
 }
 
 }  // namespace web