components/search_provider_logos/logo_tracker_unittest.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 <vector>
   8
   9 #include "base/base64.h"
  10 #include "base/bind.h"
  11 #include "base/callback.h"
  12 #include "base/files/file_path.h"
  13 #include "base/json/json_writer.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_vector.h"
  16 #include "base/run_loop.h"
  17 #include "base/strings/string_piece.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/test/simple_test_clock.h"
  20 #include "base/time/time.h"
  21 #include "base/values.h"
  22 #include "components/search_provider_logos/google_logo_api.h"
  23 #include "net/base/url_util.h"
  24 #include "net/http/http_response_headers.h"
  25 #include "net/http/http_status_code.h"
  26 #include "net/url_request/test_url_fetcher_factory.h"
  27 #include "net/url_request/url_request_status.h"
  28 #include "net/url_request/url_request_test_util.h"
  29 #include "testing/gmock/include/gmock/gmock.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31 #include "ui/gfx/image/image.h"
  32
  33 using ::testing::_;
  34 using ::testing::AnyNumber;
  35 using ::testing::AtMost;
  36 using ::testing::InSequence;
  37 using ::testing::Invoke;
  38 using ::testing::Mock;
  39 using ::testing::NiceMock;
  40 using ::testing::Return;
  41
  42 namespace search_provider_logos {
  43
  44 namespace {
  45
  46 bool AreImagesSameSize(const SkBitmap& bitmap1, const SkBitmap& bitmap2) {
  47   return bitmap1.width() == bitmap2.width() &&
  48          bitmap1.height() == bitmap2.height();
  49 }
  50
  51 scoped_refptr<base::RefCountedString> EncodeBitmapAsPNG(
  52     const SkBitmap& bitmap) {
  53   scoped_refptr<base::RefCountedMemory> png_bytes =
  54       gfx::Image::CreateFrom1xBitmap(bitmap).As1xPNGBytes();
  55   scoped_refptr<base::RefCountedString> str = new base::RefCountedString();
  56   str->data().assign(png_bytes->front_as<char>(), png_bytes->size());
  57   return str;
  58 }
  59
  60 std::string EncodeBitmapAsPNGBase64(const SkBitmap& bitmap) {
  61   scoped_refptr<base::RefCountedString> png_bytes = EncodeBitmapAsPNG(bitmap);
  62   std::string encoded_image_base64;
  63   base::Base64Encode(png_bytes->data(), &encoded_image_base64);
  64   return encoded_image_base64;
  65 }
  66
  67 SkBitmap MakeBitmap(int width, int height) {
  68   SkBitmap bitmap;
  69   bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
  70   bitmap.allocPixels();
  71   bitmap.eraseColor(SK_ColorBLUE);
  72   return bitmap;
  73 }
  74
  75 EncodedLogo EncodeLogo(const Logo& logo) {
  76   EncodedLogo encoded_logo;
  77   encoded_logo.encoded_image = EncodeBitmapAsPNG(logo.image);
  78   encoded_logo.metadata = logo.metadata;
  79   return encoded_logo;
  80 }
  81
  82 Logo DecodeLogo(const EncodedLogo& encoded_logo) {
  83   Logo logo;
  84   logo.image = gfx::Image::CreateFrom1xPNGBytes(
  85       encoded_logo.encoded_image->front(),
  86       encoded_logo.encoded_image->size()).AsBitmap();
  87   logo.metadata = encoded_logo.metadata;
  88   return logo;
  89 }
  90
  91 Logo GetSampleLogo(const GURL& logo_url, base::Time response_time) {
  92   Logo logo;
  93   logo.image = MakeBitmap(2, 5);
  94   logo.metadata.can_show_after_expiration = false;
  95   logo.metadata.expiration_time =
  96       response_time + base::TimeDelta::FromHours(19);
  97   logo.metadata.fingerprint = "8bc33a80";
  98   logo.metadata.source_url = logo_url.spec();
  99   logo.metadata.on_click_url = "http://www.google.com/search?q=potato";
 100   logo.metadata.alt_text = "A logo about potatoes";
 101   logo.metadata.mime_type = "image/png";
 102   return logo;
 103 }
 104
 105 Logo GetSampleLogo2(const GURL& logo_url, base::Time response_time) {
 106   Logo logo;
 107   logo.image = MakeBitmap(4, 3);
 108   logo.metadata.can_show_after_expiration = true;
 109   logo.metadata.expiration_time = base::Time();
 110   logo.metadata.fingerprint = "71082741021409127";
 111   logo.metadata.source_url = logo_url.spec();
 112   logo.metadata.on_click_url = "http://example.com/page25";
 113   logo.metadata.alt_text = "The logo for example.com";
 114   logo.metadata.mime_type = "image/png";
 115   return logo;
 116 }
 117
 118 std::string MakeServerResponse(
 119     const SkBitmap& image,
 120     const std::string& on_click_url,
 121     const std::string& alt_text,
 122     const std::string& mime_type,
 123     const std::string& fingerprint,
 124     base::TimeDelta time_to_live) {
 125   base::DictionaryValue dict;
 126   if (!image.isNull()) {
 127     dict.SetString("update.logo.data", EncodeBitmapAsPNGBase64(image));
 128   }
 129
 130   dict.SetString("update.logo.target", on_click_url);
 131   dict.SetString("update.logo.alt", alt_text);
 132   dict.SetString("update.logo.mime_type", mime_type);
 133   dict.SetString("update.logo.fingerprint", fingerprint);
 134   if (time_to_live.ToInternalValue() != 0)
 135     dict.SetInteger("update.logo.time_to_live",
 136                     static_cast<int>(time_to_live.InMilliseconds()));
 137
 138   std::string output;
 139   base::JSONWriter::Write(&dict, &output);
 140   return output;
 141 }
 142
 143 std::string MakeServerResponse(const Logo& logo, base::TimeDelta time_to_live) {
 144   return MakeServerResponse(logo.image,
 145                             logo.metadata.on_click_url,
 146                             logo.metadata.alt_text,
 147                             logo.metadata.mime_type,
 148                             logo.metadata.fingerprint,
 149                             time_to_live);
 150 }
 151
 152 void ExpectLogosEqual(const Logo* expected_logo,
 153                       const Logo* actual_logo) {
 154   if (!expected_logo) {
 155     ASSERT_FALSE(actual_logo);
 156     return;
 157   }
 158   ASSERT_TRUE(actual_logo);
 159   EXPECT_TRUE(AreImagesSameSize(expected_logo->image, actual_logo->image));
 160   EXPECT_EQ(expected_logo->metadata.on_click_url,
 161             actual_logo->metadata.on_click_url);
 162   EXPECT_EQ(expected_logo->metadata.source_url,
 163             actual_logo->metadata.source_url);
 164   EXPECT_EQ(expected_logo->metadata.fingerprint,
 165             actual_logo->metadata.fingerprint);
 166   EXPECT_EQ(expected_logo->metadata.can_show_after_expiration,
 167             actual_logo->metadata.can_show_after_expiration);
 168 }
 169
 170 void ExpectLogosEqual(const Logo* expected_logo,
 171                       const EncodedLogo* actual_encoded_logo) {
 172   Logo actual_logo;
 173   if (actual_encoded_logo)
 174     actual_logo = DecodeLogo(*actual_encoded_logo);
 175   ExpectLogosEqual(expected_logo, actual_encoded_logo ? &actual_logo : NULL);
 176 }
 177
 178 ACTION_P(ExpectLogosEqualAction, expected_logo) {
 179   ExpectLogosEqual(expected_logo, arg0);
 180 }
 181
 182 class MockLogoCache : public LogoCache {
 183  public:
 184   MockLogoCache() : LogoCache(base::FilePath()) {
 185     // Delegate actions to the *Internal() methods by default.
 186     ON_CALL(*this, UpdateCachedLogoMetadata(_)).WillByDefault(
 187         Invoke(this, &MockLogoCache::UpdateCachedLogoMetadataInternal));
 188     ON_CALL(*this, GetCachedLogoMetadata()).WillByDefault(
 189         Invoke(this, &MockLogoCache::GetCachedLogoMetadataInternal));
 190     ON_CALL(*this, SetCachedLogo(_))
 191         .WillByDefault(Invoke(this, &MockLogoCache::SetCachedLogoInternal));
 192   }
 193
 194   MOCK_METHOD1(UpdateCachedLogoMetadata, void(const LogoMetadata& metadata));
 195   MOCK_METHOD0(GetCachedLogoMetadata, const LogoMetadata*());
 196   MOCK_METHOD1(SetCachedLogo, void(const EncodedLogo* logo));
 197   // GetCachedLogo() can't be mocked since it returns a scoped_ptr, which is
 198   // non-copyable. Instead create a method that's pinged when GetCachedLogo() is
 199   // called.
 200   MOCK_METHOD0(OnGetCachedLogo, void());
 201
 202   void EncodeAndSetCachedLogo(const Logo& logo) {
 203     EncodedLogo encoded_logo = EncodeLogo(logo);
 204     SetCachedLogo(&encoded_logo);
 205   }
 206
 207   void ExpectSetCachedLogo(const Logo* expected_logo) {
 208     Mock::VerifyAndClearExpectations(this);
 209     EXPECT_CALL(*this, SetCachedLogo(_))
 210         .WillOnce(ExpectLogosEqualAction(expected_logo));
 211   }
 212
 213   void UpdateCachedLogoMetadataInternal(const LogoMetadata& metadata) {
 214     metadata_.reset(new LogoMetadata(metadata));
 215   }
 216
 217   virtual const LogoMetadata* GetCachedLogoMetadataInternal() {
 218     return metadata_.get();
 219   }
 220
 221   virtual void SetCachedLogoInternal(const EncodedLogo* logo) {
 222     logo_.reset(logo ? new EncodedLogo(*logo) : NULL);
 223     metadata_.reset(logo ? new LogoMetadata(logo->metadata) : NULL);
 224   }
 225
 226   virtual scoped_ptr<EncodedLogo> GetCachedLogo() OVERRIDE {
 227     return make_scoped_ptr(logo_ ? new EncodedLogo(*logo_) : NULL);
 228     OnGetCachedLogo();
 229   }
 230
 231  private:
 232   scoped_ptr<LogoMetadata> metadata_;
 233   scoped_ptr<EncodedLogo> logo_;
 234 };
 235
 236 class MockLogoObserver : public LogoObserver {
 237  public:
 238   virtual ~MockLogoObserver() {}
 239
 240   void ExpectNoLogo() {
 241     Mock::VerifyAndClearExpectations(this);
 242     EXPECT_CALL(*this, OnLogoAvailable(_, _)).Times(0);
 243     EXPECT_CALL(*this, OnObserverRemoved()).Times(1);
 244   }
 245
 246   void ExpectCachedLogo(const Logo* expected_cached_logo) {
 247     Mock::VerifyAndClearExpectations(this);
 248     EXPECT_CALL(*this, OnLogoAvailable(_, true))
 249         .WillOnce(ExpectLogosEqualAction(expected_cached_logo));
 250     EXPECT_CALL(*this, OnLogoAvailable(_, false)).Times(0);
 251     EXPECT_CALL(*this, OnObserverRemoved()).Times(1);
 252   }
 253
 254   void ExpectFreshLogo(const Logo* expected_fresh_logo) {
 255     Mock::VerifyAndClearExpectations(this);
 256     EXPECT_CALL(*this, OnLogoAvailable(_, true)).Times(0);
 257     EXPECT_CALL(*this, OnLogoAvailable(NULL, true));
 258     EXPECT_CALL(*this, OnLogoAvailable(_, false))
 259         .WillOnce(ExpectLogosEqualAction(expected_fresh_logo));
 260     EXPECT_CALL(*this, OnObserverRemoved()).Times(1);
 261   }
 262
 263   void ExpectCachedAndFreshLogos(const Logo* expected_cached_logo,
 264                                  const Logo* expected_fresh_logo) {
 265     Mock::VerifyAndClearExpectations(this);
 266     InSequence dummy;
 267     EXPECT_CALL(*this, OnLogoAvailable(_, true))
 268         .WillOnce(ExpectLogosEqualAction(expected_cached_logo));
 269     EXPECT_CALL(*this, OnLogoAvailable(_, false))
 270         .WillOnce(ExpectLogosEqualAction(expected_fresh_logo));
 271     EXPECT_CALL(*this, OnObserverRemoved()).Times(1);
 272   }
 273
 274   MOCK_METHOD2(OnLogoAvailable, void(const Logo*, bool));
 275   MOCK_METHOD0(OnObserverRemoved, void());
 276 };
 277
 278 class TestLogoDelegate : public LogoDelegate {
 279  public:
 280   TestLogoDelegate() {}
 281   virtual ~TestLogoDelegate() {}
 282
 283   virtual void DecodeUntrustedImage(
 284       const scoped_refptr<base::RefCountedString>& encoded_image,
 285       base::Callback<void(const SkBitmap&)> image_decoded_callback) OVERRIDE {
 286     SkBitmap bitmap =
 287         gfx::Image::CreateFrom1xPNGBytes(encoded_image->front(),
 288                                          encoded_image->size()).AsBitmap();
 289     base::MessageLoopProxy::current()->PostTask(
 290         FROM_HERE, base::Bind(image_decoded_callback, bitmap));
 291   }
 292 };
 293
 294 class LogoTrackerTest : public ::testing::Test {
 295  protected:
 296   LogoTrackerTest()
 297       : message_loop_(new base::MessageLoop()),
 298         logo_url_("https://google.com/doodleoftheday?size=hp"),
 299         test_clock_(new base::SimpleTestClock()),
 300         logo_cache_(new NiceMock<MockLogoCache>()),
 301         fake_url_fetcher_factory_(NULL) {
 302     test_clock_->SetNow(base::Time::FromJsTime(GG_INT64_C(1388686828000)));
 303     logo_tracker_ = new LogoTracker(
 304         base::FilePath(),
 305         base::MessageLoopProxy::current(),
 306         base::MessageLoopProxy::current(),
 307         new net::TestURLRequestContextGetter(base::MessageLoopProxy::current()),
 308         scoped_ptr<LogoDelegate>(new TestLogoDelegate()));
 309     logo_tracker_->SetServerAPI(logo_url_,
 310                                 base::Bind(&GoogleParseLogoResponse),
 311                                 base::Bind(&GoogleAppendFingerprintToLogoURL));
 312     logo_tracker_->SetClockForTests(scoped_ptr<base::Clock>(test_clock_));
 313     logo_tracker_->SetLogoCacheForTests(scoped_ptr<LogoCache>(logo_cache_));
 314   }
 315
 316   virtual void TearDown() {
 317     // logo_tracker_ owns logo_cache_, which gets destructed on the file thread
 318     // after logo_tracker_'s destruction. Ensure that logo_cache_ is actually
 319     // destructed before the test ends to make gmock happy.
 320     delete logo_tracker_;
 321     message_loop_->RunUntilIdle();
 322   }
 323
 324   // Returns the response that the server would send for the given logo.
 325   std::string ServerResponse(const Logo& logo) const;
 326
 327   // Sets the response to be returned when the LogoTracker fetches the logo.
 328   void SetServerResponse(const std::string& response,
 329                          net::URLRequestStatus::Status request_status =
 330                              net::URLRequestStatus::SUCCESS,
 331                          net::HttpStatusCode response_code = net::HTTP_OK);
 332
 333   // Sets the response to be returned when the LogoTracker fetches the logo and
 334   // provides the given fingerprint.
 335   void SetServerResponseWhenFingerprint(
 336       const std::string& fingerprint,
 337       const std::string& response_when_fingerprint,
 338       net::URLRequestStatus::Status request_status =
 339           net::URLRequestStatus::SUCCESS,
 340       net::HttpStatusCode response_code = net::HTTP_OK);
 341
 342   // Calls logo_tracker_->GetLogo() with listener_ and waits for the
 343   // asynchronous response(s).
 344   void GetLogo();
 345
 346   scoped_ptr<base::MessageLoop> message_loop_;
 347   GURL logo_url_;
 348   base::SimpleTestClock* test_clock_;
 349   NiceMock<MockLogoCache>* logo_cache_;
 350   net::FakeURLFetcherFactory fake_url_fetcher_factory_;
 351   LogoTracker* logo_tracker_;
 352   NiceMock<MockLogoObserver> observer_;
 353 };
 354
 355 std::string LogoTrackerTest::ServerResponse(const Logo& logo) const {
 356   base::TimeDelta time_to_live;
 357   if (!logo.metadata.expiration_time.is_null())
 358     time_to_live = logo.metadata.expiration_time - test_clock_->Now();
 359   return MakeServerResponse(logo, time_to_live);
 360 }
 361
 362 void LogoTrackerTest::SetServerResponse(
 363     const std::string& response,
 364     net::URLRequestStatus::Status request_status,
 365     net::HttpStatusCode response_code) {
 366   fake_url_fetcher_factory_.SetFakeResponse(
 367       logo_url_, response, response_code, request_status);
 368 }
 369
 370 void LogoTrackerTest::SetServerResponseWhenFingerprint(
 371     const std::string& fingerprint,
 372     const std::string& response_when_fingerprint,
 373     net::URLRequestStatus::Status request_status,
 374     net::HttpStatusCode response_code) {
 375   GURL url_with_fp =
 376       net::AppendQueryParameter(logo_url_, "async", "es_dfp:" + fingerprint);
 377   fake_url_fetcher_factory_.SetFakeResponse(
 378       url_with_fp, response_when_fingerprint, response_code, request_status);
 379 }
 380
 381 void LogoTrackerTest::GetLogo() {
 382   logo_tracker_->GetLogo(&observer_);
 383   base::RunLoop().RunUntilIdle();
 384 }
 385
 386 // Tests -----------------------------------------------------------------------
 387
 388 TEST_F(LogoTrackerTest, DownloadAndCacheLogo) {
 389   Logo logo = GetSampleLogo(logo_url_, test_clock_->Now());
 390   SetServerResponse(ServerResponse(logo));
 391   logo_cache_->ExpectSetCachedLogo(&logo);
 392   observer_.ExpectFreshLogo(&logo);
 393   GetLogo();
 394 }
 395
 396 TEST_F(LogoTrackerTest, EmptyCacheAndFailedDownload) {
 397   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 398   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
 399   EXPECT_CALL(*logo_cache_, SetCachedLogo(NULL)).Times(AnyNumber());
 400
 401   SetServerResponse("server is borked");
 402   observer_.ExpectCachedLogo(NULL);
 403   GetLogo();
 404
 405   SetServerResponse("", net::URLRequestStatus::FAILED, net::HTTP_OK);
 406   observer_.ExpectCachedLogo(NULL);
 407   GetLogo();
 408
 409   SetServerResponse("", net::URLRequestStatus::SUCCESS, net::HTTP_BAD_GATEWAY);
 410   observer_.ExpectCachedLogo(NULL);
 411   GetLogo();
 412 }
 413
 414 TEST_F(LogoTrackerTest, AcceptMinimalLogoResponse) {
 415   Logo logo;
 416   logo.image = MakeBitmap(1, 2);
 417   logo.metadata.source_url = logo_url_.spec();
 418   logo.metadata.can_show_after_expiration = true;
 419
 420   std::string response = ")]}' {\"update\":{\"logo\":{\"data\":\"" +
 421                          EncodeBitmapAsPNGBase64(logo.image) +
 422                          "\",\"mime_type\":\"image/png\"}}}";
 423
 424   SetServerResponse(response);
 425   observer_.ExpectFreshLogo(&logo);
 426   GetLogo();
 427 }
 428
 429 TEST_F(LogoTrackerTest, ReturnCachedLogo) {
 430   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 431   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 432   SetServerResponseWhenFingerprint(cached_logo.metadata.fingerprint,
 433                                    "",
 434                                    net::URLRequestStatus::FAILED,
 435                                    net::HTTP_OK);
 436
 437   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 438   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
 439   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 440   observer_.ExpectCachedLogo(&cached_logo);
 441   GetLogo();
 442 }
 443
 444 TEST_F(LogoTrackerTest, ValidateCachedLogoFingerprint) {
 445   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 446   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 447
 448   Logo fresh_logo = cached_logo;
 449   fresh_logo.image.reset();
 450   fresh_logo.metadata.expiration_time =
 451       test_clock_->Now() + base::TimeDelta::FromDays(8);
 452   SetServerResponseWhenFingerprint(fresh_logo.metadata.fingerprint,
 453                                    ServerResponse(fresh_logo));
 454
 455   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(1);
 456   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
 457   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 458   observer_.ExpectCachedLogo(&cached_logo);
 459
 460   GetLogo();
 461
 462   EXPECT_TRUE(logo_cache_->GetCachedLogoMetadata() != NULL);
 463   EXPECT_EQ(logo_cache_->GetCachedLogoMetadata()->expiration_time,
 464             fresh_logo.metadata.expiration_time);
 465 }
 466
 467 TEST_F(LogoTrackerTest, UpdateCachedLogo) {
 468   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 469   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 470
 471   Logo fresh_logo = GetSampleLogo2(logo_url_, test_clock_->Now());
 472   SetServerResponseWhenFingerprint(cached_logo.metadata.fingerprint,
 473                                    ServerResponse(fresh_logo));
 474
 475   logo_cache_->ExpectSetCachedLogo(&fresh_logo);
 476   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 477   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 478   observer_.ExpectCachedAndFreshLogos(&cached_logo, &fresh_logo);
 479
 480   GetLogo();
 481 }
 482
 483 TEST_F(LogoTrackerTest, InvalidateCachedLogo) {
 484   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 485   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 486
 487   // This response means there's no current logo.
 488   SetServerResponseWhenFingerprint(cached_logo.metadata.fingerprint,
 489                                    ")]}' {\"update\":{}}");
 490
 491   logo_cache_->ExpectSetCachedLogo(NULL);
 492   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 493   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 494   observer_.ExpectCachedAndFreshLogos(&cached_logo, NULL);
 495
 496   GetLogo();
 497 }
 498
 499 TEST_F(LogoTrackerTest, DeleteCachedLogoFromOldUrl) {
 500   SetServerResponse("", net::URLRequestStatus::FAILED, net::HTTP_OK);
 501   Logo cached_logo =
 502       GetSampleLogo(GURL("http://oldsearchprovider.com"), test_clock_->Now());
 503   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 504
 505   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 506   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
 507   EXPECT_CALL(*logo_cache_, SetCachedLogo(NULL)).Times(AnyNumber());
 508   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 509   observer_.ExpectCachedLogo(NULL);
 510   GetLogo();
 511 }
 512
 513 TEST_F(LogoTrackerTest, LogoWithTTLCannotBeShownAfterExpiration) {
 514   Logo logo = GetSampleLogo(logo_url_, test_clock_->Now());
 515   base::TimeDelta time_to_live = base::TimeDelta::FromDays(3);
 516   logo.metadata.expiration_time = test_clock_->Now() + time_to_live;
 517   SetServerResponse(ServerResponse(logo));
 518   GetLogo();
 519
 520   const LogoMetadata* cached_metadata =
 521       logo_cache_->GetCachedLogoMetadata();
 522   EXPECT_TRUE(cached_metadata != NULL);
 523   EXPECT_FALSE(cached_metadata->can_show_after_expiration);
 524   EXPECT_EQ(test_clock_->Now() + time_to_live,
 525             cached_metadata->expiration_time);
 526 }
 527
 528 TEST_F(LogoTrackerTest, LogoWithoutTTLCanBeShownAfterExpiration) {
 529   Logo logo = GetSampleLogo(logo_url_, test_clock_->Now());
 530   base::TimeDelta time_to_live = base::TimeDelta();
 531   SetServerResponse(MakeServerResponse(logo, time_to_live));
 532   GetLogo();
 533
 534   const LogoMetadata* cached_metadata =
 535       logo_cache_->GetCachedLogoMetadata();
 536   EXPECT_TRUE(cached_metadata != NULL);
 537   EXPECT_TRUE(cached_metadata->can_show_after_expiration);
 538   EXPECT_EQ(test_clock_->Now() + base::TimeDelta::FromDays(30),
 539             cached_metadata->expiration_time);
 540 }
 541
 542 TEST_F(LogoTrackerTest, UseSoftExpiredCachedLogo) {
 543   SetServerResponse("", net::URLRequestStatus::FAILED, net::HTTP_OK);
 544   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 545   cached_logo.metadata.expiration_time =
 546       test_clock_->Now() - base::TimeDelta::FromSeconds(1);
 547   cached_logo.metadata.can_show_after_expiration = true;
 548   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 549
 550   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 551   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
 552   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 553   observer_.ExpectCachedLogo(&cached_logo);
 554   GetLogo();
 555 }
 556
 557 TEST_F(LogoTrackerTest, RerequestSoftExpiredCachedLogo) {
 558   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 559   cached_logo.metadata.expiration_time =
 560       test_clock_->Now() - base::TimeDelta::FromDays(5);
 561   cached_logo.metadata.can_show_after_expiration = true;
 562   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 563
 564   Logo fresh_logo = GetSampleLogo2(logo_url_, test_clock_->Now());
 565   SetServerResponse(ServerResponse(fresh_logo));
 566
 567   logo_cache_->ExpectSetCachedLogo(&fresh_logo);
 568   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 569   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 570   observer_.ExpectCachedAndFreshLogos(&cached_logo, &fresh_logo);
 571
 572   GetLogo();
 573 }
 574
 575 TEST_F(LogoTrackerTest, DeleteAncientCachedLogo) {
 576   SetServerResponse("", net::URLRequestStatus::FAILED, net::HTTP_OK);
 577   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 578   cached_logo.metadata.expiration_time =
 579       test_clock_->Now() - base::TimeDelta::FromDays(200);
 580   cached_logo.metadata.can_show_after_expiration = true;
 581   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 582
 583   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 584   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
 585   EXPECT_CALL(*logo_cache_, SetCachedLogo(NULL)).Times(AnyNumber());
 586   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 587   observer_.ExpectCachedLogo(NULL);
 588   GetLogo();
 589 }
 590
 591 TEST_F(LogoTrackerTest, DeleteExpiredCachedLogo) {
 592   SetServerResponse("", net::URLRequestStatus::FAILED, net::HTTP_OK);
 593   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 594   cached_logo.metadata.expiration_time =
 595       test_clock_->Now() - base::TimeDelta::FromSeconds(1);
 596   cached_logo.metadata.can_show_after_expiration = false;
 597   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 598
 599   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
 600   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
 601   EXPECT_CALL(*logo_cache_, SetCachedLogo(NULL)).Times(AnyNumber());
 602   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
 603   observer_.ExpectCachedLogo(NULL);
 604   GetLogo();
 605 }
 606
 607 // Tests that deal with multiple listeners.
 608
 609 void EnqueueObservers(LogoTracker* logo_tracker,
 610                       const ScopedVector<MockLogoObserver>& observers,
 611                       size_t start_index) {
 612   if (start_index >= observers.size())
 613     return;
 614
 615   logo_tracker->GetLogo(observers[start_index]);
 616   base::MessageLoop::current()->PostTask(FROM_HERE,
 617                                          base::Bind(&EnqueueObservers,
 618                                                     logo_tracker,
 619                                                     base::ConstRef(observers),
 620                                                     start_index + 1));
 621 }
 622
 623 TEST_F(LogoTrackerTest, SupportOverlappingLogoRequests) {
 624   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
 625   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 626   ON_CALL(*logo_cache_, SetCachedLogo(_)).WillByDefault(Return());
 627
 628   Logo fresh_logo = GetSampleLogo2(logo_url_, test_clock_->Now());
 629   std::string response = ServerResponse(fresh_logo);
 630   SetServerResponse(response);
 631   SetServerResponseWhenFingerprint(cached_logo.metadata.fingerprint, response);
 632
 633   const int kNumListeners = 10;
 634   ScopedVector<MockLogoObserver> listeners;
 635   for (int i = 0; i < kNumListeners; ++i) {
 636     MockLogoObserver* listener = new MockLogoObserver();
 637     listener->ExpectCachedAndFreshLogos(&cached_logo, &fresh_logo);
 638     listeners.push_back(listener);
 639   }
 640   EnqueueObservers(logo_tracker_, listeners, 0);
 641
 642   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(AtMost(3));
 643   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(3));
 644
 645   base::RunLoop().RunUntilIdle();
 646 }
 647
 648 TEST_F(LogoTrackerTest, DeleteObserversWhenLogoURLChanged) {
 649   MockLogoObserver listener1;
 650   listener1.ExpectNoLogo();
 651   logo_tracker_->GetLogo(&listener1);
 652
 653   logo_url_ = GURL("http://example.com/new-logo-url");
 654   logo_tracker_->SetServerAPI(logo_url_,
 655                               base::Bind(&GoogleParseLogoResponse),
 656                               base::Bind(&GoogleAppendFingerprintToLogoURL));
 657   Logo logo = GetSampleLogo(logo_url_, test_clock_->Now());
 658   SetServerResponse(ServerResponse(logo));
 659
 660   MockLogoObserver listener2;
 661   listener2.ExpectFreshLogo(&logo);
 662   logo_tracker_->GetLogo(&listener2);
 663
 664   base::RunLoop().RunUntilIdle();
 665 }
 666
 667 }  // namespace
 668
 669 }  // namespace search_provider_logos