Fix metadata loss when revalidating search provider logo.

components/search_provider_logos/logo_tracker_unittest.cc

 // Copyright 2014 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/search_provider_logos/logo_tracker.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 93 matching lines @@
 
 Logo GetSampleLogo2(const GURL& logo_url, base::Time response_time) {
   Logo logo;
   logo.image = MakeBitmap(4, 3);
   logo.metadata.can_show_after_expiration = true;
   logo.metadata.expiration_time = base::Time();
   logo.metadata.fingerprint = "71082741021409127";
   logo.metadata.source_url = logo_url.spec();
   logo.metadata.on_click_url = "http://example.com/page25";
   logo.metadata.alt_text = "The logo for example.com";
-  logo.metadata.mime_type = "image/png";
+  logo.metadata.mime_type = "image/jpeg";
   return logo;
 }
 
 std::string MakeServerResponse(
     const SkBitmap& image,
     const std::string& on_click_url,
     const std::string& alt_text,
     const std::string& animated_url,
     const std::string& mime_type,
     const std::string& fingerprint,
     base::TimeDelta time_to_live) {
   base::DictionaryValue dict;
-  if (!image.isNull()) {
+  if (!image.isNull())
     dict.SetString("update.logo.data", EncodeBitmapAsPNGBase64(image));
-  }
 
   dict.SetString("update.logo.target", on_click_url);
   dict.SetString("update.logo.alt", alt_text);
-  if (!animated_url.empty()) {
+  if (!animated_url.empty())
     dict.SetString("update.logo.url", animated_url);
-  }
-  dict.SetString("update.logo.mime_type", mime_type);
+  if (!mime_type.empty())
+    dict.SetString("update.logo.mime_type", mime_type);
   dict.SetString("update.logo.fingerprint", fingerprint);
   if (time_to_live.ToInternalValue() != 0)
     dict.SetInteger("update.logo.time_to_live",
                     static_cast<int>(time_to_live.InMilliseconds()));
 
   std::string output;
   base::JSONWriter::Write(&dict, &output);
   return output;
 }
 
@@ skipping 68 matching lines @@
     SetCachedLogo(&encoded_logo);
   }
 
   void ExpectSetCachedLogo(const Logo* expected_logo) {
     Mock::VerifyAndClearExpectations(this);
     EXPECT_CALL(*this, SetCachedLogo(_))
         .WillOnce(ExpectLogosEqualAction(expected_logo));
   }
 
   void UpdateCachedLogoMetadataInternal(const LogoMetadata& metadata) {
+    ASSERT_TRUE(logo_.get());
+    ASSERT_TRUE(metadata_.get());
+    EXPECT_EQ(metadata_->fingerprint, metadata.fingerprint);
     metadata_.reset(new LogoMetadata(metadata));
+    logo_->metadata = metadata;
   }
 
   virtual const LogoMetadata* GetCachedLogoMetadataInternal() {
     return metadata_.get();
   }
 
   virtual void SetCachedLogoInternal(const EncodedLogo* logo) {
     logo_.reset(logo ? new EncodedLogo(*logo) : NULL);
     metadata_.reset(logo ? new LogoMetadata(logo->metadata) : NULL);
   }
@@ skipping 231 matching lines @@
                                    net::URLRequestStatus::FAILED,
                                    net::HTTP_OK);
 
   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
   observer_.ExpectCachedLogo(&cached_logo);
   GetLogo();
 }
 
-TEST_F(LogoTrackerTest, ValidateCachedLogoFingerprint) {
+TEST_F(LogoTrackerTest, ValidateCachedLogo) {
   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 
+  // During revalidation, the image data and mime_type are absent.
   Logo fresh_logo = cached_logo;
   fresh_logo.image.reset();
+  fresh_logo.metadata.mime_type.clear();
   fresh_logo.metadata.expiration_time =
       test_clock_->Now() + base::TimeDelta::FromDays(8);
   SetServerResponseWhenFingerprint(fresh_logo.metadata.fingerprint,
                                    ServerResponse(fresh_logo));
 
   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(1);
   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
   observer_.ExpectCachedLogo(&cached_logo);
-
   GetLogo();
 
   EXPECT_TRUE(logo_cache_->GetCachedLogoMetadata() != NULL);
-  EXPECT_EQ(logo_cache_->GetCachedLogoMetadata()->expiration_time,
-            fresh_logo.metadata.expiration_time);
+  EXPECT_EQ(fresh_logo.metadata.expiration_time,
+            logo_cache_->GetCachedLogoMetadata()->expiration_time);
+
+  // Ensure that cached logo is still returned correctly on subsequent requests.
+  // In particular, the metadata should stay valid. http://crbug.com/480090
+  EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(1);
+  EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
+  EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
+  observer_.ExpectCachedLogo(&cached_logo);
+  GetLogo();
+}
+
+TEST_F(LogoTrackerTest, UpdateCachedLogoMetadata) {
+  Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
+  logo_cache_->EncodeAndSetCachedLogo(cached_logo);
+
+  Logo fresh_logo = cached_logo;
+  fresh_logo.image.reset();
+  fresh_logo.metadata.mime_type.clear();
+  fresh_logo.metadata.on_click_url = "http://new.onclick.url";
+  fresh_logo.metadata.alt_text = "new alt text";
+  fresh_logo.metadata.animated_url = "http://new.animated.url";
+  fresh_logo.metadata.expiration_time =
+      test_clock_->Now() + base::TimeDelta::FromDays(8);
+  SetServerResponseWhenFingerprint(fresh_logo.metadata.fingerprint,
+                                   ServerResponse(fresh_logo));
+
+  // On the first request, the cached logo should be used.
+  observer_.ExpectCachedLogo(&cached_logo);
+  GetLogo();
+
+  // Subsequently, the cached image should be returned along with the updated
+  // metadata.
+  Logo expected_logo = fresh_logo;
+  expected_logo.image = cached_logo.image;
+  expected_logo.metadata.mime_type = cached_logo.metadata.mime_type;
+  observer_.ExpectCachedLogo(&expected_logo);
+  GetLogo();
 }
 
 TEST_F(LogoTrackerTest, UpdateCachedLogo) {
   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
 
   Logo fresh_logo = GetSampleLogo2(logo_url_, test_clock_->Now());
   SetServerResponseWhenFingerprint(cached_logo.metadata.fingerprint,
                                    ServerResponse(fresh_logo));
 
@@ skipping 185 matching lines @@
   MockLogoObserver listener2;
   listener2.ExpectFreshLogo(&logo);
   logo_tracker_->GetLogo(&listener2);
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace search_provider_logos