chrome/browser/chromeos/policy/cloud_external_data_store.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/policy/cloud_external_data_store.h"
   6
   7 #include <set>
   8
   9 #include "base/logging.h"
  10 #include "base/sequenced_task_runner.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "components/policy/core/common/cloud/resource_cache.h"
  13 #include "crypto/sha2.h"
  14
  15 namespace policy {
  16
  17 namespace {
  18
  19 // Encodes (policy, hash) into a single string.
  20 std::string GetSubkey(const std::string& policy, const std::string& hash) {
  21   DCHECK(!policy.empty());
  22   DCHECK(!hash.empty());
  23   return base::IntToString(policy.size()) + ":" +
  24          base::IntToString(hash.size()) + ":" +
  25          policy + hash;
  26 }
  27
  28 }  // namespace
  29
  30 CloudExternalDataStore::CloudExternalDataStore(
  31     const std::string& cache_key,
  32     scoped_refptr<base::SequencedTaskRunner> task_runner,
  33     ResourceCache* cache)
  34     : cache_key_(cache_key),
  35       task_runner_(task_runner),
  36       cache_(cache) {
  37 }
  38
  39 CloudExternalDataStore::~CloudExternalDataStore() {
  40   DCHECK(task_runner_->RunsTasksOnCurrentThread());
  41 }
  42
  43 void CloudExternalDataStore::Prune(
  44     const CloudExternalDataManager::Metadata& metadata) {
  45   DCHECK(task_runner_->RunsTasksOnCurrentThread());
  46   std::set<std::string> subkeys_to_keep;
  47   for (CloudExternalDataManager::Metadata::const_iterator it = metadata.begin();
  48        it != metadata.end(); ++it) {
  49     subkeys_to_keep.insert(GetSubkey(it->first, it->second.hash));
  50   }
  51   cache_->PurgeOtherSubkeys(cache_key_, subkeys_to_keep);
  52 }
  53
  54 bool CloudExternalDataStore::Store(const std::string& policy,
  55                                    const std::string& hash,
  56                                    const std::string& data) {
  57   DCHECK(task_runner_->RunsTasksOnCurrentThread());
  58   return cache_->Store(cache_key_, GetSubkey(policy, hash), data);
  59 }
  60
  61 bool CloudExternalDataStore::Load(const std::string& policy,
  62                                   const std::string& hash,
  63                                   size_t max_size,
  64                                   std::string* data) {
  65   DCHECK(task_runner_->RunsTasksOnCurrentThread());
  66   const std::string subkey = GetSubkey(policy, hash);
  67   if (cache_->Load(cache_key_, subkey, data)) {
  68     if (data->size() <= max_size && crypto::SHA256HashString(*data) == hash)
  69       return true;
  70     // If the data is larger than allowed or does not match the expected hash,
  71     // delete the entry.
  72     cache_->Delete(cache_key_, subkey);
  73     data->clear();
  74   }
  75   return false;
  76 }
  77
  78 }  // namespace policy