Cleanup: Rename is_hsts_host to fatal.

net/url_request/url_request_test_util.h

 // Copyright (c) 2011 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
 #define NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
 #pragma once
 
 #include <stdlib.h>
 
@@ skipping 102 matching lines @@
   int response_started_count() const { return response_started_count_; }
   int received_redirect_count() const { return received_redirect_count_; }
   int blocked_get_cookies_count() const { return blocked_get_cookies_count_; }
   int blocked_set_cookie_count() const { return blocked_set_cookie_count_; }
   int set_cookie_count() const { return set_cookie_count_; }
   bool received_data_before_response() const {
     return received_data_before_response_;
   }
   bool request_failed() const { return request_failed_; }
   bool have_certificate_errors() const { return have_certificate_errors_; }
-  bool is_hsts_host() const { return is_hsts_host_; }
+  bool certificate_errors_are_fatal() const {
+    return certificate_errors_are_fatal_;
+  }
   bool auth_required_called() const { return auth_required_; }
 
   // net::URLRequest::Delegate:
   virtual void OnReceivedRedirect(net::URLRequest* request, const GURL& new_url,
                                   bool* defer_redirect) OVERRIDE;
   virtual void OnAuthRequired(net::URLRequest* request,
                               net::AuthChallengeInfo* auth_info) OVERRIDE;
+  // NOTE: |fatal| causes |certificate_errors_are_fatal_| to be set to true.
+  // (Unit tests use this as a post-condition.) But for policy, this method
+  // consults |allow_certificate_errors_|.
   virtual void OnSSLCertificateError(net::URLRequest* request,
                                      const net::SSLInfo& ssl_info,
-                                     bool is_hsts_host) OVERRIDE;
+                                     bool fatal) OVERRIDE;
   virtual bool CanGetCookies(const net::URLRequest* request,
                              const net::CookieList& cookie_list) const OVERRIDE;
   virtual bool CanSetCookie(const net::URLRequest* request,
                             const std::string& cookie_line,
                             net::CookieOptions* options) const OVERRIDE;
   virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
   virtual void OnReadCompleted(net::URLRequest* request,
                                int bytes_read) OVERRIDE;
 
  private:
@@ skipping 15 matching lines @@
   // tracks status of callbacks
   int response_started_count_;
   int received_bytes_count_;
   int received_redirect_count_;
   mutable int blocked_get_cookies_count_;
   mutable int blocked_set_cookie_count_;
   mutable int set_cookie_count_;
   bool received_data_before_response_;
   bool request_failed_;
   bool have_certificate_errors_;
-  bool is_hsts_host_;
+  bool certificate_errors_are_fatal_;
   bool auth_required_;
   std::string data_received_;
 
   // our read buffer
   scoped_refptr<net::IOBuffer> buf_;
 };
 
 //-----------------------------------------------------------------------------
 
 class TestNetworkDelegate : public net::NetworkDelegate {
@@ skipping 51 matching lines @@
   // This bit-set indicates for each request id (key) what events may be sent
   // next.
   std::map<int, int> next_states_;
 
   // A log that records for each request id (key) the order in which On...
   // functions were called.
   std::map<int, std::string> event_order_;
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_