Use {To/From}JavaTime for policy timestamps

components/policy/core/common/cloud/component_cloud_policy_store.cc

 // Copyright (c) 2013 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 "components/policy/core/common/cloud/component_cloud_policy_store.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 54 matching lines @@
 }
 
 const DomainConstants* GetDomainConstantsForType(const std::string& type) {
   for (const DomainConstants& constants : kDomains) {
     if (constants.policy_type == type)
       return &constants;
   }
   return nullptr;
 }
 
-base::Time GetTimeFromPolicyTimestamp(int64_t timestamp) {
-  return base::Time::UnixEpoch() + base::TimeDelta::FromMilliseconds(timestamp);
-}
-
 }  // namespace
 
 ComponentCloudPolicyStore::Delegate::~Delegate() {}
 
 ComponentCloudPolicyStore::ComponentCloudPolicyStore(Delegate* delegate,
                                                      ResourceCache* cache)
     : delegate_(delegate), cache_(cache) {
   // Allow the store to be created on a different thread than the thread that
   // will end up using it.
   DetachFromThread();
@@ skipping 75 matching lines @@
 
       // The protobuf looks good; load the policy data.
       std::string data;
       PolicyMap policy;
       if (cache_->Load(constants.data_cache_key, id, &data) &&
           ValidateData(data, payload.secure_hash(), &policy)) {
         // The data is also good; expose the policies.
         policy_bundle_.Get(ns).Swap(&policy);
         cached_hashes_[ns] = payload.secure_hash();
         stored_policy_times_[ns] =
-            GetTimeFromPolicyTimestamp(policy_data.timestamp());
+            base::Time::FromJavaTime(policy_data.timestamp());
       } else {
         // The data for this proto couldn't be loaded or is corrupted.
         Delete(ns);
       }
     }
   }
 }
 
 bool ComponentCloudPolicyStore::Store(
     const PolicyNamespace& ns,
     const std::string& serialized_policy,
     std::unique_ptr<em::PolicyData> policy_data,
     const std::string& secure_hash,
     const std::string& data) {
   DCHECK(CalledOnValidThread());
   const DomainConstants* constants = GetDomainConstants(ns.domain);
   PolicyMap policy;
   // |serialized_policy| has already been validated; validate the data now.
   if (!constants)
     return false;
   if (!ValidateData(data, secure_hash, &policy))
     return false;
 
   // Flush the proto and the data to the cache.
   cache_->Store(constants->proto_cache_key, ns.component_id, serialized_policy);
   cache_->Store(constants->data_cache_key, ns.component_id, data);
   // And expose the policy.
   policy_bundle_.Get(ns).Swap(&policy);
   cached_hashes_[ns] = secure_hash;
-  stored_policy_times_[ns] =
-      GetTimeFromPolicyTimestamp(policy_data->timestamp());
+  stored_policy_times_[ns] = base::Time::FromJavaTime(policy_data->timestamp());
   delegate_->OnComponentCloudPolicyStoreUpdated();
   return true;
 }
 
 void ComponentCloudPolicyStore::Delete(const PolicyNamespace& ns) {
   DCHECK(CalledOnValidThread());
   const DomainConstants* constants = GetDomainConstants(ns.domain);
   if (!constants)
     return;
 
@@ skipping 186 matching lines @@
     // this must support a configurable scope; assuming POLICY_SCOPE_USER is
     // fine for now.
     policy->Set(it.key(), level, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
                 std::move(value), nullptr);
   }
 
   return true;
 }
 
 }  // namespace policy