Switch to standard integer types in chrome/browser/, part 4 of 4.

chrome/browser/ssl/chrome_ssl_host_state_delegate.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 "chrome/browser/ssl/chrome_ssl_host_state_delegate.h"
 
+#include <stdint.h>
+
 #include <set>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/clock.h"
@@ skipping 163 matching lines @@
 
   // Extract the certificate decision's expiration time from the content
   // setting. If there is no expiration time, that means it should never expire
   // and it should reset only at session restart, so skip all of the expiration
   // checks.
   bool expired = false;
   base::Time now = clock_->Now();
   base::Time decision_expiration;
   if (dict->HasKey(kSSLCertDecisionExpirationTimeKey)) {
     std::string decision_expiration_string;
-    int64 decision_expiration_int64;
+    int64_t decision_expiration_int64;
     success = dict->GetString(kSSLCertDecisionExpirationTimeKey,
                               &decision_expiration_string);
     if (!base::StringToInt64(base::StringPiece(decision_expiration_string),
                              &decision_expiration_int64)) {
       LOG(ERROR) << "Failed to parse a certificate error exception that has a "
                  << "bad value for an expiration time: "
                  << decision_expiration_string;
       return NULL;
     }
     decision_expiration =
         base::Time::FromInternalValue(decision_expiration_int64);
   }
 
   // Check to see if the user's certificate decision has expired.
   // - Expired and |create_entries| is DO_NOT_CREATE_DICTIONARY_ENTRIES, return
   // NULL.
   // - Expired and |create_entries| is CREATE_DICTIONARY_ENTRIES, update the
   // expiration time.
   if (should_remember_ssl_decisions_ !=
           FORGET_SSL_EXCEPTION_DECISIONS_AT_SESSION_END &&
       decision_expiration.ToInternalValue() <= now.ToInternalValue()) {
     *expired_previous_decision = true;
 
     if (create_entries == DO_NOT_CREATE_DICTIONARY_ENTRIES)
       return NULL;
 
     expired = true;
     base::Time expiration_time =
         now + base::TimeDelta::FromSeconds(kDeltaDefaultExpirationInSeconds);
-    // Unfortunately, JSON (and thus content settings) doesn't support int64
+    // Unfortunately, JSON (and thus content settings) doesn't support int64_t
     // values, only doubles. Since this mildly depends on precision, it is
     // better to store the value as a string.
     dict->SetString(kSSLCertDecisionExpirationTimeKey,
                     base::Int64ToString(expiration_time.ToInternalValue()));
   } else if (should_remember_ssl_decisions_ ==
              FORGET_SSL_EXCEPTION_DECISIONS_AT_SESSION_END) {
     if (dict->HasKey(kSSLCertDecisionGUIDKey)) {
       std::string old_expiration_guid;
       success = dict->GetString(kSSLCertDecisionGUIDKey, &old_expiration_guid);
       if (old_expiration_guid.compare(current_expiration_guid_) != 0) {
@@ skipping 204 matching lines @@
 }
 
 bool ChromeSSLHostStateDelegate::DidHostRunInsecureContent(
     const std::string& host,
     int pid) const {
   return !!ran_insecure_content_hosts_.count(BrokenHostEntry(host, pid));
 }
 void ChromeSSLHostStateDelegate::SetClock(scoped_ptr<base::Clock> clock) {
   clock_.reset(clock.release());
 }