components/search_provider_logos/logo_tracker.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_tracker.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/task_runner_util.h"
  11 #include "base/thread_task_runner_handle.h"
  12 #include "base/time/default_clock.h"
  13 #include "net/http/http_response_headers.h"
  14 #include "net/url_request/url_fetcher.h"
  15 #include "net/url_request/url_request_context_getter.h"
  16 #include "net/url_request/url_request_status.h"
  17
  18 namespace search_provider_logos {
  19
  20 namespace {
  21
  22 const int64 kMaxDownloadBytes = 1024 * 1024;
  23
  24 //const int kDecodeLogoTimeoutSeconds = 30;
  25
  26 // Returns whether the metadata for the cached logo indicates that the logo is
  27 // OK to show, i.e. it's not expired or it's allowed to be shown temporarily
  28 // after expiration.
  29 bool IsLogoOkToShow(const LogoMetadata& metadata, base::Time now) {
  30   base::TimeDelta offset =
  31       base::TimeDelta::FromMilliseconds(kMaxTimeToLiveMS * 3 / 2);
  32   base::Time distant_past = now - offset;
  33   base::Time distant_future = now + offset;
  34   // Sanity check so logos aren't accidentally cached forever.
  35   if (metadata.expiration_time < distant_past ||
  36       metadata.expiration_time > distant_future) {
  37     return false;
  38   }
  39   return metadata.can_show_after_expiration || metadata.expiration_time >= now;
  40 }
  41
  42 // Reads the logo from the cache and returns it. Returns NULL if the cache is
  43 // empty, corrupt, expired, or doesn't apply to the current logo URL.
  44 scoped_ptr<EncodedLogo> GetLogoFromCacheOnFileThread(LogoCache* logo_cache,
  45                                               const GURL& logo_url,
  46                                               base::Time now) {
  47   const LogoMetadata* metadata = logo_cache->GetCachedLogoMetadata();
  48   if (!metadata)
  49     return scoped_ptr<EncodedLogo>();
  50
  51   if (metadata->source_url != logo_url.spec() ||
  52       !IsLogoOkToShow(*metadata, now)) {
  53     logo_cache->SetCachedLogo(NULL);
  54     return scoped_ptr<EncodedLogo>();
  55   }
  56
  57   return logo_cache->GetCachedLogo().Pass();
  58 }
  59
  60 void DeleteLogoCacheOnFileThread(LogoCache* logo_cache) {
  61   delete logo_cache;
  62 }
  63
  64 }  // namespace
  65
  66 LogoTracker::LogoTracker(
  67     base::FilePath cached_logo_directory,
  68     scoped_refptr<base::SequencedTaskRunner> file_task_runner,
  69     scoped_refptr<base::TaskRunner> background_task_runner,
  70     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
  71     scoped_ptr<LogoDelegate> delegate)
  72     : is_idle_(true),
  73       is_cached_logo_valid_(false),
  74       logo_delegate_(delegate.Pass()),
  75       logo_cache_(new LogoCache(cached_logo_directory)),
  76       clock_(new base::DefaultClock()),
  77       file_task_runner_(file_task_runner),
  78       background_task_runner_(background_task_runner),
  79       request_context_getter_(request_context_getter),
  80       weak_ptr_factory_(this) {}
  81
  82 LogoTracker::~LogoTracker() {
  83   ReturnToIdle();
  84   file_task_runner_->PostTask(
  85       FROM_HERE, base::Bind(&DeleteLogoCacheOnFileThread, logo_cache_));
  86   logo_cache_ = NULL;
  87 }
  88
  89 void LogoTracker::SetServerAPI(
  90     const GURL& logo_url,
  91     const ParseLogoResponse& parse_logo_response_func,
  92     const AppendFingerprintToLogoURL& append_fingerprint_func) {
  93   if (logo_url == logo_url_)
  94     return;
  95
  96   ReturnToIdle();
  97
  98   logo_url_ = logo_url;
  99   parse_logo_response_func_ = parse_logo_response_func;
 100   append_fingerprint_func_ = append_fingerprint_func;
 101 }
 102
 103 void LogoTracker::GetLogo(LogoObserver* observer) {
 104   DCHECK(!logo_url_.is_empty());
 105   logo_observers_.AddObserver(observer);
 106
 107   if (is_idle_) {
 108     is_idle_ = false;
 109     base::PostTaskAndReplyWithResult(
 110         file_task_runner_,
 111         FROM_HERE,
 112         base::Bind(&GetLogoFromCacheOnFileThread,
 113                    logo_cache_,
 114                    logo_url_,
 115                    clock_->Now()),
 116         base::Bind(&LogoTracker::OnCachedLogoRead,
 117                    weak_ptr_factory_.GetWeakPtr()));
 118   } else if (is_cached_logo_valid_) {
 119     observer->OnLogoAvailable(cached_logo_.get(), true);
 120   }
 121 }
 122
 123 void LogoTracker::RemoveObserver(LogoObserver* observer) {
 124   logo_observers_.RemoveObserver(observer);
 125 }
 126
 127 void LogoTracker::SetLogoCacheForTests(scoped_ptr<LogoCache> cache) {
 128   DCHECK(cache);
 129   file_task_runner_->PostTask(
 130         FROM_HERE, base::Bind(&DeleteLogoCacheOnFileThread, logo_cache_));
 131   logo_cache_ = cache.release();
 132 }
 133
 134 void LogoTracker::SetClockForTests(scoped_ptr<base::Clock> clock) {
 135   clock_ = clock.Pass();
 136 }
 137
 138 void LogoTracker::ReturnToIdle() {
 139   // Cancel the current asynchronous operation, if any.
 140   fetcher_.reset();
 141   weak_ptr_factory_.InvalidateWeakPtrs();
 142
 143   // Reset state.
 144   is_idle_ = true;
 145   cached_logo_.reset();
 146   is_cached_logo_valid_ = false;
 147
 148   // Clear obsevers.
 149   FOR_EACH_OBSERVER(LogoObserver, logo_observers_, OnObserverRemoved());
 150   logo_observers_.Clear();
 151 }
 152
 153 void LogoTracker::OnCachedLogoRead(scoped_ptr<EncodedLogo> cached_logo) {
 154   DCHECK(!is_idle_);
 155
 156   if (cached_logo) {
 157     logo_delegate_->DecodeUntrustedImage(
 158         cached_logo->encoded_image,
 159         base::Bind(&LogoTracker::OnCachedLogoAvailable,
 160                    weak_ptr_factory_.GetWeakPtr(),
 161                    cached_logo->metadata));
 162   } else {
 163     OnCachedLogoAvailable(LogoMetadata(), SkBitmap());
 164   }
 165 }
 166
 167 void LogoTracker::OnCachedLogoAvailable(const LogoMetadata& metadata,
 168                                         const SkBitmap& image) {
 169   DCHECK(!is_idle_);
 170
 171   if (!image.isNull()) {
 172     cached_logo_.reset(new Logo());
 173     cached_logo_->metadata = metadata;
 174     cached_logo_->image = image;
 175   }
 176   is_cached_logo_valid_ = true;
 177   Logo* logo = cached_logo_.get();
 178   FOR_EACH_OBSERVER(LogoObserver, logo_observers_, OnLogoAvailable(logo, true));
 179   FetchLogo();
 180 }
 181
 182 void LogoTracker::SetCachedLogo(scoped_ptr<EncodedLogo> logo) {
 183   file_task_runner_->PostTask(
 184       FROM_HERE,
 185       base::Bind(&LogoCache::SetCachedLogo,
 186                  base::Unretained(logo_cache_),
 187                  base::Owned(logo.release())));
 188 }
 189
 190 void LogoTracker::SetCachedMetadata(const LogoMetadata& metadata) {
 191   file_task_runner_->PostTask(FROM_HERE,
 192                               base::Bind(&LogoCache::UpdateCachedLogoMetadata,
 193                                          base::Unretained(logo_cache_),
 194                                          metadata));
 195 }
 196
 197 void LogoTracker::FetchLogo() {
 198   DCHECK(!fetcher_);
 199   DCHECK(!is_idle_);
 200
 201   GURL url;
 202   if (cached_logo_ && !cached_logo_->metadata.fingerprint.empty() &&
 203       cached_logo_->metadata.expiration_time >= clock_->Now()) {
 204     url = append_fingerprint_func_.Run(logo_url_,
 205                                        cached_logo_->metadata.fingerprint);
 206   } else {
 207     url = logo_url_;
 208   }
 209
 210   fetcher_.reset(net::URLFetcher::Create(url, net::URLFetcher::GET, this));
 211   fetcher_->SetRequestContext(request_context_getter_);
 212   fetcher_->Start();
 213 }
 214
 215 void LogoTracker::OnFreshLogoParsed(scoped_ptr<EncodedLogo> logo) {
 216   DCHECK(!is_idle_);
 217
 218   if (logo)
 219     logo->metadata.source_url = logo_url_.spec();
 220
 221   if (!logo || !logo->encoded_image) {
 222     OnFreshLogoAvailable(logo.Pass(), SkBitmap());
 223   } else {
 224     // Store the value of logo->encoded_image for use below. This ensures that
 225     // logo->encoded_image is evaulated before base::Passed(&logo), which sets
 226     // logo to NULL.
 227     scoped_refptr<base::RefCountedString> encoded_image = logo->encoded_image;
 228     logo_delegate_->DecodeUntrustedImage(
 229         encoded_image,
 230         base::Bind(&LogoTracker::OnFreshLogoAvailable,
 231                    weak_ptr_factory_.GetWeakPtr(),
 232                    base::Passed(&logo)));
 233   }
 234 }
 235
 236 void LogoTracker::OnFreshLogoAvailable(scoped_ptr<EncodedLogo> encoded_logo,
 237                                        const SkBitmap& image) {
 238   DCHECK(!is_idle_);
 239
 240   if (encoded_logo && !encoded_logo->encoded_image && cached_logo_ &&
 241       !encoded_logo->metadata.fingerprint.empty() &&
 242       encoded_logo->metadata.fingerprint ==
 243           cached_logo_->metadata.fingerprint) {
 244     // The cached logo was revalidated, i.e. its fingerprint was verified.
 245     SetCachedMetadata(encoded_logo->metadata);
 246   } else if (encoded_logo && image.isNull()) {
 247     // Image decoding failed. Do nothing.
 248   } else {
 249     scoped_ptr<Logo> logo;
 250     // Check if the server returned a valid, non-empty response.
 251     if (encoded_logo) {
 252       DCHECK(!image.isNull());
 253       logo.reset(new Logo());
 254       logo->metadata = encoded_logo->metadata;
 255       logo->image = image;
 256     }
 257
 258     // Notify observers if a new logo was fetched, or if the new logo is NULL
 259     // but the cached logo was non-NULL.
 260     if (logo || cached_logo_) {
 261       FOR_EACH_OBSERVER(LogoObserver,
 262                         logo_observers_,
 263                         OnLogoAvailable(logo.get(), false));
 264       SetCachedLogo(encoded_logo.Pass());
 265     }
 266   }
 267
 268   ReturnToIdle();
 269 }
 270
 271 void LogoTracker::OnURLFetchComplete(const net::URLFetcher* source) {
 272   DCHECK(!is_idle_);
 273   scoped_ptr<net::URLFetcher> cleanup_fetcher(fetcher_.release());
 274
 275   if (!source->GetStatus().is_success() || (source->GetResponseCode() != 200)) {
 276     ReturnToIdle();
 277     return;
 278   }
 279
 280   scoped_ptr<std::string> response(new std::string());
 281   source->GetResponseAsString(response.get());
 282   base::Time response_time = clock_->Now();
 283
 284   base::PostTaskAndReplyWithResult(
 285       background_task_runner_,
 286       FROM_HERE,
 287       base::Bind(parse_logo_response_func_,
 288                  base::Passed(&response),
 289                  response_time),
 290       base::Bind(&LogoTracker::OnFreshLogoParsed,
 291                  weak_ptr_factory_.GetWeakPtr()));
 292 }
 293
 294 void LogoTracker::OnURLFetchDownloadProgress(const net::URLFetcher* source,
 295                                              int64 current,
 296                                              int64 total) {
 297   if (total > kMaxDownloadBytes || current > kMaxDownloadBytes) {
 298     LOG(WARNING) << "Search provider logo exceeded download size limit";
 299     ReturnToIdle();
 300   }
 301 }
 302
 303 }  // namespace search_provider_logos