Make callers of FromUTC(Local)Exploded in net/ use new time API.

net/cert/ct_policy_enforcer_unittest.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 "net/cert/ct_policy_enforcer.h"
 
 #include <memory>
 #include <string>
 
 #include "base/time/time.h"
@@ skipping 67 matching lines @@
     for (size_t i = 0; i < num_scts; ++i) {
       scoped_refptr<ct::SignedCertificateTimestamp> sct(
           new ct::SignedCertificateTimestamp());
       sct->origin = desired_origin;
       if (i < desired_log_keys.size())
         sct->log_id = desired_log_keys[i];
       else
         sct->log_id = std::string(crypto::kSHA256Length, static_cast<char>(i));
 
       if (timestamp_past_enforcement_date) {
-        sct->timestamp =
-            base::Time::FromUTCExploded({2015, 8, 0, 15, 0, 0, 0, 0});
+        EXPECT_TRUE(base::Time::FromUTCExploded({2015, 8, 0, 15, 0, 0, 0, 0},
+                                                &sct->timestamp));
       } else {
-        sct->timestamp =
-            base::Time::FromUTCExploded({2015, 6, 0, 15, 0, 0, 0, 0});
+        EXPECT_TRUE(base::Time::FromUTCExploded({2015, 6, 0, 15, 0, 0, 0, 0},
+                                                &sct->timestamp));
       }
 
       verified_scts->push_back(sct);
     }
   }
 
   void AddDisqualifiedLogSCT(
       ct::SignedCertificateTimestamp::Origin desired_origin,
       bool timestamp_after_disqualification_date,
       ct::SCTList* verified_scts) {
     static const char kCertlyLogID[] =
         "\xcd\xb5\x17\x9b\x7f\xc1\xc0\x46\xfe\xea\x31\x13\x6a\x3f\x8f\x00\x2e"
         "\x61\x82\xfa\xf8\x89\x6f\xec\xc8\xb2\xf5\xb5\xab\x60\x49\x00";
     static_assert(arraysize(kCertlyLogID) - 1 == crypto::kSHA256Length,
                   "Incorrect log ID length.");
 
     scoped_refptr<ct::SignedCertificateTimestamp> sct(
         new ct::SignedCertificateTimestamp());
     sct->origin = desired_origin;
     sct->log_id = std::string(kCertlyLogID, crypto::kSHA256Length);
     if (timestamp_after_disqualification_date) {
-      sct->timestamp =
-          base::Time::FromUTCExploded({2016, 4, 0, 16, 0, 0, 0, 0});
+      EXPECT_TRUE(base::Time::FromUTCExploded({2016, 4, 0, 16, 0, 0, 0, 0},
+                                              &sct->timestamp));
     } else {
-      sct->timestamp = base::Time::FromUTCExploded({2016, 4, 0, 1, 0, 0, 0, 0});
+      EXPECT_TRUE(base::Time::FromUTCExploded({2016, 4, 0, 1, 0, 0, 0, 0},
+                                              &sct->timestamp));
     }
 
     verified_scts->push_back(sct);
   }
 
   void FillListWithSCTsOfOrigin(
       ct::SignedCertificateTimestamp::Origin desired_origin,
       size_t num_scts,
       ct::SCTList* verified_scts) {
     std::vector<std::string> desired_log_ids;
     desired_log_ids.push_back(google_log_id_);
     FillListWithSCTsOfOrigin(desired_origin, num_scts, desired_log_ids, true,
                              verified_scts);
   }
 
+  base::Time CreateTime(const base::Time::Exploded& exploded) {
+    base::Time result;
+    if (!base::Time::FromUTCExploded(exploded, &result)) {
+      ADD_FAILURE() << "Failed FromUTCExploded";
+    }
+    return result;
+  }
+
  protected:
   std::unique_ptr<CTPolicyEnforcer> policy_enforcer_;
   scoped_refptr<X509Certificate> chain_;
   std::string google_log_id_;
   std::string non_google_log_id_;
 };
 
 #if defined(OS_ANDROID)
 #define MAYBE_DoesNotConformToCTEVPolicyNotEnoughDiverseSCTsAllGoogle \
   DISABLED_DoesNotConformToCTEVPolicyNotEnoughDiverseSCTsAllGoogle
@@ skipping 300 matching lines @@
                 chain_.get(), nullptr, scts, NetLogWithSource()));
 }
 
 TEST_F(CTPolicyEnforcerTest,
        ConformsToPolicyExactNumberOfSCTsForValidityPeriod) {
   std::unique_ptr<crypto::RSAPrivateKey> private_key(
       crypto::RSAPrivateKey::Create(1024));
   ASSERT_TRUE(private_key);
 
   // Test multiple validity periods
+  base::Time time_2015_3_0_25_11_25_0_0 =
+      CreateTime({2015, 3, 0, 25, 11, 25, 0, 0});
+
+  base::Time time_2016_6_0_6_11_25_0_0 =
+      CreateTime({2016, 6, 0, 6, 11, 25, 0, 0});
+
+  base::Time time_2016_6_0_25_11_25_0_0 =
+      CreateTime({2016, 6, 0, 25, 11, 25, 0, 0});
+
+  base::Time time_2016_6_0_27_11_25_0_0 =
+      CreateTime({2016, 6, 0, 27, 11, 25, 0, 0});
+
+  base::Time time_2017_6_0_25_11_25_0_0 =
+      CreateTime({2017, 6, 0, 25, 11, 25, 0, 0});
+
+  base::Time time_2017_6_0_28_11_25_0_0 =
+      CreateTime({2017, 6, 0, 28, 11, 25, 0, 0});
+
+  base::Time time_2018_6_0_25_11_25_0_0 =
+      CreateTime({2018, 6, 0, 25, 11, 25, 0, 0});
+
+  base::Time time_2018_6_0_27_11_25_0_0 =
+      CreateTime({2018, 6, 0, 27, 11, 25, 0, 0});
+
   const struct TestData {
     base::Time validity_start;
     base::Time validity_end;
     size_t scts_required;
   } kTestData[] = {{// Cert valid for 14 months, needs 2 SCTs.
-                    base::Time::FromUTCExploded({2015, 3, 0, 25, 11, 25, 0, 0}),
-                    base::Time::FromUTCExploded({2016, 6, 0, 6, 11, 25, 0, 0}),
-                    2},
+                    time_2015_3_0_25_11_25_0_0, time_2016_6_0_6_11_25_0_0, 2},
                    {// Cert valid for exactly 15 months, needs 3 SCTs.
-                    base::Time::FromUTCExploded({2015, 3, 0, 25, 11, 25, 0, 0}),
-                    base::Time::FromUTCExploded({2016, 6, 0, 25, 11, 25, 0, 0}),
-                    3},
+                    time_2015_3_0_25_11_25_0_0, time_2016_6_0_25_11_25_0_0, 3},
                    {// Cert valid for over 15 months, needs 3 SCTs.
-                    base::Time::FromUTCExploded({2015, 3, 0, 25, 11, 25, 0, 0}),
-                    base::Time::FromUTCExploded({2016, 6, 0, 27, 11, 25, 0, 0}),
-                    3},
+                    time_2015_3_0_25_11_25_0_0, time_2016_6_0_27_11_25_0_0, 3},
                    {// Cert valid for exactly 27 months, needs 3 SCTs.
-                    base::Time::FromUTCExploded({2015, 3, 0, 25, 11, 25, 0, 0}),
-                    base::Time::FromUTCExploded({2017, 6, 0, 25, 11, 25, 0, 0}),
-                    3},
+                    time_2015_3_0_25_11_25_0_0, time_2017_6_0_25_11_25_0_0, 3},
                    {// Cert valid for over 27 months, needs 4 SCTs.
-                    base::Time::FromUTCExploded({2015, 3, 0, 25, 11, 25, 0, 0}),
-                    base::Time::FromUTCExploded({2017, 6, 0, 28, 11, 25, 0, 0}),
-                    4},
+                    time_2015_3_0_25_11_25_0_0, time_2017_6_0_28_11_25_0_0, 4},
                    {// Cert valid for exactly 39 months, needs 4 SCTs.
-                    base::Time::FromUTCExploded({2015, 3, 0, 25, 11, 25, 0, 0}),
-                    base::Time::FromUTCExploded({2018, 6, 0, 25, 11, 25, 0, 0}),
-                    4},
+                    time_2015_3_0_25_11_25_0_0, time_2018_6_0_25_11_25_0_0, 4},
                    {// Cert valid for over 39 months, needs 5 SCTs.
-                    base::Time::FromUTCExploded({2015, 3, 0, 25, 11, 25, 0, 0}),
-                    base::Time::FromUTCExploded({2018, 6, 0, 27, 11, 25, 0, 0}),
-                    5}};
+                    time_2015_3_0_25_11_25_0_0, time_2018_6_0_27_11_25_0_0, 5}};
 
   for (size_t i = 0; i < arraysize(kTestData); ++i) {
     SCOPED_TRACE(i);
     const base::Time& start = kTestData[i].validity_start;
     const base::Time& end = kTestData[i].validity_end;
     size_t required_scts = kTestData[i].scts_required;
 
     // Create a self-signed certificate with exactly the validity period.
     std::string cert_data;
     ASSERT_TRUE(x509_util::CreateSelfSignedCert(
@@ skipping 67 matching lines @@
   FillListWithSCTsOfOrigin(ct::SignedCertificateTimestamp::SCT_EMBEDDED, 2,
                            &scts);
   EXPECT_EQ(ct::EVPolicyCompliance::EV_POLICY_NOT_ENOUGH_SCTS,
             policy_enforcer_->DoesConformToCTEVPolicy(
                 chain_.get(), nullptr, scts, NetLogWithSource()));
 }
 
 }  // namespace
 
 }  // namespace net