components/search_provider_logos/logo_cache.cc

   1 // Copyright 2014 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 "components/search_provider_logos/logo_cache.h"
   6
   7 #include "base/files/file_util.h"
   8 #include "base/json/json_reader.h"
   9 #include "base/json/json_writer.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/values.h"
  12
  13 namespace {
  14
  15 // The cached logo metadata is persisted as JSON using these keys.
  16 const char kSourceUrlKey[] = "url";
  17 const char kExpirationTimeKey[] = "expiration_time";
  18 const char kCanShowAfterExpirationKey[] = "can_show_after_expiration";
  19 const char kFingerprintKey[] = "fingerprint";
  20 const char kOnClickURLKey[] = "on_click_url";
  21 const char kAltTextKey[] = "alt_text";
  22 const char kMimeTypeKey[] = "mime_type";
  23 const char kNumBytesKey[] = "num_bytes";
  24 const char kAnimatedUrlKey[] = "animated_url";
  25
  26 bool GetTimeValue(const base::DictionaryValue& dict,
  27                   const std::string& key,
  28                   base::Time* time) {
  29   std::string str;
  30   int64 internal_time_value;
  31   if (dict.GetString(key, &str) &&
  32       base::StringToInt64(str, &internal_time_value)) {
  33     *time = base::Time::FromInternalValue(internal_time_value);
  34     return true;
  35   }
  36   return false;
  37 }
  38
  39 void SetTimeValue(base::DictionaryValue& dict,
  40                   const std::string& key,
  41                   const base::Time& time) {
  42   int64 internal_time_value = time.ToInternalValue();
  43   dict.SetString(key, base::Int64ToString(internal_time_value));
  44 }
  45
  46 }  // namespace
  47
  48 namespace search_provider_logos {
  49
  50 LogoCache::LogoCache(const base::FilePath& cache_directory)
  51     : cache_directory_(cache_directory),
  52       metadata_is_valid_(false) {
  53   // The LogoCache can be constructed on any thread, as long as it's used
  54   // on a single thread after construction.
  55   thread_checker_.DetachFromThread();
  56 }
  57
  58 LogoCache::~LogoCache() {
  59   DCHECK(thread_checker_.CalledOnValidThread());
  60 }
  61
  62 void LogoCache::UpdateCachedLogoMetadata(const LogoMetadata& metadata) {
  63   DCHECK(thread_checker_.CalledOnValidThread());
  64   DCHECK(metadata_);
  65   DCHECK_EQ(metadata_->fingerprint, metadata.fingerprint);
  66
  67   UpdateMetadata(make_scoped_ptr(new LogoMetadata(metadata)));
  68   WriteMetadata();
  69 }
  70
  71 const LogoMetadata* LogoCache::GetCachedLogoMetadata() {
  72   DCHECK(thread_checker_.CalledOnValidThread());
  73   ReadMetadataIfNeeded();
  74   return metadata_.get();
  75 }
  76
  77 void LogoCache::SetCachedLogo(const EncodedLogo* logo) {
  78   DCHECK(thread_checker_.CalledOnValidThread());
  79   scoped_ptr<LogoMetadata> metadata;
  80   if (logo) {
  81     metadata.reset(new LogoMetadata(logo->metadata));
  82     logo_num_bytes_ = static_cast<int>(logo->encoded_image->size());
  83   }
  84   UpdateMetadata(metadata.Pass());
  85   WriteLogo(logo ? logo->encoded_image : NULL);
  86 }
  87
  88 scoped_ptr<EncodedLogo> LogoCache::GetCachedLogo() {
  89   DCHECK(thread_checker_.CalledOnValidThread());
  90
  91   ReadMetadataIfNeeded();
  92   if (!metadata_)
  93     return scoped_ptr<EncodedLogo>();
  94
  95   scoped_refptr<base::RefCountedString> encoded_image =
  96       new base::RefCountedString();
  97   if (!base::ReadFileToString(GetLogoPath(), &encoded_image->data())) {
  98     UpdateMetadata(scoped_ptr<LogoMetadata>());
  99     return scoped_ptr<EncodedLogo>();
 100   }
 101
 102   if (encoded_image->size() != static_cast<size_t>(logo_num_bytes_)) {
 103     // Delete corrupt metadata and logo.
 104     DeleteLogoAndMetadata();
 105     UpdateMetadata(scoped_ptr<LogoMetadata>());
 106     return scoped_ptr<EncodedLogo>();
 107   }
 108
 109   scoped_ptr<EncodedLogo> logo(new EncodedLogo());
 110   logo->encoded_image = encoded_image;
 111   logo->metadata = *metadata_;
 112   return logo.Pass();
 113 }
 114
 115 // static
 116 scoped_ptr<LogoMetadata> LogoCache::LogoMetadataFromString(
 117     const std::string& str, int* logo_num_bytes) {
 118   scoped_ptr<base::Value> value = base::JSONReader::Read(str);
 119   base::DictionaryValue* dict;
 120   if (!value || !value->GetAsDictionary(&dict))
 121     return scoped_ptr<LogoMetadata>();
 122
 123   scoped_ptr<LogoMetadata> metadata(new LogoMetadata());
 124   if (!dict->GetString(kSourceUrlKey, &metadata->source_url) ||
 125       !dict->GetString(kFingerprintKey, &metadata->fingerprint) ||
 126       !dict->GetString(kOnClickURLKey, &metadata->on_click_url) ||
 127       !dict->GetString(kAltTextKey, &metadata->alt_text) ||
 128       !dict->GetString(kAnimatedUrlKey, &metadata->animated_url) ||
 129       !dict->GetString(kMimeTypeKey, &metadata->mime_type) ||
 130       !dict->GetBoolean(kCanShowAfterExpirationKey,
 131                         &metadata->can_show_after_expiration) ||
 132       !dict->GetInteger(kNumBytesKey, logo_num_bytes) ||
 133       !GetTimeValue(*dict, kExpirationTimeKey, &metadata->expiration_time)) {
 134     return scoped_ptr<LogoMetadata>();
 135   }
 136
 137   return metadata.Pass();
 138 }
 139
 140 // static
 141 void LogoCache::LogoMetadataToString(const LogoMetadata& metadata,
 142                                      int num_bytes,
 143                                      std::string* str) {
 144   base::DictionaryValue dict;
 145   dict.SetString(kSourceUrlKey, metadata.source_url);
 146   dict.SetString(kFingerprintKey, metadata.fingerprint);
 147   dict.SetString(kOnClickURLKey, metadata.on_click_url);
 148   dict.SetString(kAltTextKey, metadata.alt_text);
 149   dict.SetString(kAnimatedUrlKey, metadata.animated_url);
 150   dict.SetString(kMimeTypeKey, metadata.mime_type);
 151   dict.SetBoolean(kCanShowAfterExpirationKey,
 152                   metadata.can_show_after_expiration);
 153   dict.SetInteger(kNumBytesKey, num_bytes);
 154   SetTimeValue(dict, kExpirationTimeKey, metadata.expiration_time);
 155   base::JSONWriter::Write(dict, str);
 156 }
 157
 158 base::FilePath LogoCache::GetLogoPath() {
 159   return cache_directory_.Append(FILE_PATH_LITERAL("logo"));
 160 }
 161
 162 base::FilePath LogoCache::GetMetadataPath() {
 163   return cache_directory_.Append(FILE_PATH_LITERAL("metadata"));
 164 }
 165
 166 void LogoCache::UpdateMetadata(scoped_ptr<LogoMetadata> metadata) {
 167   metadata_ = metadata.Pass();
 168   metadata_is_valid_ = true;
 169 }
 170
 171 void LogoCache::ReadMetadataIfNeeded() {
 172   if (metadata_is_valid_)
 173     return;
 174
 175   scoped_ptr<LogoMetadata> metadata;
 176   base::FilePath metadata_path = GetMetadataPath();
 177   std::string str;
 178   if (base::ReadFileToString(metadata_path, &str)) {
 179     metadata = LogoMetadataFromString(str, &logo_num_bytes_);
 180     if (!metadata) {
 181       // Delete corrupt metadata and logo.
 182       DeleteLogoAndMetadata();
 183     }
 184   }
 185
 186   UpdateMetadata(metadata.Pass());
 187 }
 188
 189 void LogoCache::WriteMetadata() {
 190   if (!EnsureCacheDirectoryExists())
 191     return;
 192
 193   std::string str;
 194   LogoMetadataToString(*metadata_, logo_num_bytes_, &str);
 195   base::WriteFile(GetMetadataPath(), str.data(), static_cast<int>(str.size()));
 196 }
 197
 198 void LogoCache::WriteLogo(scoped_refptr<base::RefCountedMemory> encoded_image) {
 199   if (!EnsureCacheDirectoryExists())
 200     return;
 201
 202   if (!metadata_ || !encoded_image.get()) {
 203     DeleteLogoAndMetadata();
 204     return;
 205   }
 206
 207   // To minimize the chances of ending up in an undetectably broken state:
 208   // First, delete the metadata file, then update the logo file, then update the
 209   // metadata file.
 210   base::FilePath logo_path = GetLogoPath();
 211   base::FilePath metadata_path = GetMetadataPath();
 212
 213   if (!base::DeleteFile(metadata_path, false))
 214     return;
 215
 216   if (base::WriteFile(
 217           logo_path,
 218           encoded_image->front_as<char>(),
 219           static_cast<int>(encoded_image->size())) == -1) {
 220     base::DeleteFile(logo_path, false);
 221     return;
 222   }
 223
 224   WriteMetadata();
 225 }
 226
 227 void LogoCache::DeleteLogoAndMetadata() {
 228   base::DeleteFile(GetLogoPath(), false);
 229   base::DeleteFile(GetMetadataPath(), false);
 230 }
 231
 232 bool LogoCache::EnsureCacheDirectoryExists() {
 233   if (base::DirectoryExists(cache_directory_))
 234     return true;
 235   return base::CreateDirectory(cache_directory_);
 236 }
 237
 238 }  // namespace search_provider_logos