Revert of Cast device revocation checking.

chrome/common/extensions/api/networking_private/networking_private_crypto.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/common/extensions/api/networking_private/networking_private_crypto.h"
 
 #include <openssl/digest.h>
 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
@@ skipping 33 matching lines @@
 }  // namespace
 
 namespace networking_private_crypto {
 
 bool VerifyCredentials(
     const std::string& certificate,
     const std::vector<std::string>& intermediate_certificates,
     const std::string& signature,
     const std::string& data,
     const std::string& connected_mac) {
-  base::Time now = base::Time::Now();
+  base::Time::Exploded now;
+  base::Time::Now().UTCExplode(&now);
   return VerifyCredentialsAtTime(certificate, intermediate_certificates,
                                  signature, data, connected_mac, now);
 }
 
 bool VerifyCredentialsAtTime(
     const std::string& certificate,
     const std::vector<std::string>& intermediate_certificates,
     const std::string& signature,
     const std::string& data,
     const std::string& connected_mac,
-    const base::Time& time) {
+    const base::Time::Exploded& time) {
   static const char kErrorPrefix[] = "Device verification failed. ";
 
   std::vector<std::string> headers;
   headers.push_back("CERTIFICATE");
 
   // Convert certificate from PEM to raw DER
   net::PEMTokenizer pem_tokenizer(certificate, headers);
   if (!pem_tokenizer.GetNext()) {
     LOG(ERROR) << kErrorPrefix << "Failed to parse device certificate.";
     return false;
@@ skipping 13 matching lines @@
       LOG(WARNING) << "Failed to parse intermediate certificates.";
     }
   }
 
   // Note that the device certificate's policy is not enforced here. The goal
   // is simply to verify that the device belongs to the Cast ecosystem.
   cast_crypto::CastDeviceCertPolicy unused_policy;
 
   std::unique_ptr<cast_crypto::CertVerificationContext> verification_context;
   if (!cast_crypto::VerifyDeviceCert(certs, time, &verification_context,
-                                     &unused_policy, nullptr,
-                                     cast_crypto::CRLPolicy::CRL_OPTIONAL)) {
+                                     &unused_policy)) {
     LOG(ERROR) << kErrorPrefix << "Failed verifying cast device cert";
     return false;
   }
 
   // Check that the device listed in the certificate is correct.
   // Something like evt_e161 001a11ffacdf
   std::string common_name = verification_context->GetCommonName();
   std::string translated_mac;
   base::RemoveChars(connected_mac, ":", &translated_mac);
   if (!base::EndsWith(common_name, translated_mac,
@@ skipping 68 matching lines @@
                           rsa.get(), RSA_PKCS1_PADDING);
   if (output_length < 0) {
     LOG(ERROR) << "Error during decryption.";
     return false;
   }
   decrypted_output->resize(output_length);
   return true;
 }
 
 }  // namespace networking_private_crypto