Extract AppBannerDataFetcher into an InstallableManager.

chrome/browser/installable/installable_checker_browsertest.cc

+// Copyright 2016 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 "chrome/browser/installable/installable_checker.h"
+
+#include "base/command_line.h"
+#include "base/run_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+
+namespace {
+
+installable::InstallableParams GetManifestParams() {
+  installable::InstallableParams params;
+  params.has_valid_webapp_manifest = false;
+  params.has_service_worker = false;
+  params.has_valid_icon = false;
+  return params;
+}
+
+installable::InstallableParams GetWebAppParams() {
+  installable::InstallableParams params = GetManifestParams();
+  params.ideal_icon_size_in_dp = 48;
+  params.minimum_icon_size_in_dp = 48;
+  params.has_valid_webapp_manifest = true;
+  params.has_service_worker = true;
+  params.has_valid_icon = true;
+  return params;
+}
+
+installable::InstallableParams GetValidManifestParams() {
+  installable::InstallableParams params = GetManifestParams();
+  params.has_valid_webapp_manifest = true;
+  return params;
+}
+
+installable::InstallableParams GetIconParams() {
+  installable::InstallableParams params = GetManifestParams();
+  params.ideal_icon_size_in_dp = 48;
+  params.minimum_icon_size_in_dp = 48;
+  params.has_valid_icon = true;
+  return params;
+}
+
+}  // anonymous namespace
+
+namespace installable {
+
+class CallbackTester {
+ public:
+  explicit CallbackTester(base::Closure quit_closure)
+      : quit_closure_(quit_closure) { }
+
+  void OnDidFinishInstallableCheck(const InstallableResult& result) {
+    error_code_ = result.error_code;
+    manifest_url_ = result.manifest_url;
+    manifest_ = result.manifest;
+    icon_url_ = result.icon_url;
+    if (result.icon)
+      icon_.reset(new SkBitmap(*result.icon));
+    has_valid_webapp_manifest_ = result.has_valid_webapp_manifest;
+    has_service_worker_ = result.has_service_worker;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure_);
+  }
+
+  ErrorCode error_code() const { return error_code_; }
+  const GURL& manifest_url() const { return manifest_url_; }
+  const content::Manifest& manifest() const { return manifest_; }
+  const GURL& icon_url() const { return icon_url_; }
+  const SkBitmap* icon() const { return icon_.get(); }
+  bool has_valid_webapp_manifest() const { return has_valid_webapp_manifest_; }
+  bool has_service_worker() const { return has_service_worker_; }
+
+ private:
+  base::Closure quit_closure_;
+  ErrorCode error_code_;
+  GURL manifest_url_;
+  content::Manifest manifest_;
+  GURL icon_url_;
+  std::unique_ptr<SkBitmap> icon_;
+  bool has_valid_webapp_manifest_;
+  bool has_service_worker_;
+};
+
+class InstallableCheckerBrowserTest : public InProcessBrowserTest {
+ public:
+  void SetUpOnMainThread() override {
+    InProcessBrowserTest::SetUpOnMainThread();
+    ASSERT_TRUE(embedded_test_server()->Start());
+  }
+
+  void NavigateAndRunInstallableChecker(CallbackTester* tester,
+                                        const InstallableParams& params,
+                                        const std::string& url) {
+    GURL test_url = embedded_test_server()->GetURL(url);
+    ui_test_utils::NavigateToURL(browser(), test_url);
+    RunInstallableChecker(tester, params);
+  }
+
+  void RunInstallableChecker(CallbackTester* tester,
+                             const InstallableParams& params) {
+    InstallableChecker* checker = GetChecker();
+    checker->Start(params,
+                   base::Bind(&CallbackTester::OnDidFinishInstallableCheck,
+                              base::Unretained(tester)));
+  }
+
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    // Make sure app banners are disabled in the browser so they do not
+    // interfere with the test.
+    command_line->AppendSwitch(switches::kDisableAddToShelf);
+  }
+
+  InstallableChecker* GetChecker() {
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    InstallableChecker::CreateForWebContents(web_contents);
+    InstallableChecker* checker =
+        InstallableChecker::FromWebContents(web_contents);
+    CHECK(checker);
+
+    return checker;
+  }
+
+};
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest,
+                       CheckerBeginsInEmptyState) {
+  // Ensure that the InstallableChecker starts off with everything null.
+  InstallableChecker* checker = GetChecker();
+
+  EXPECT_TRUE(checker->manifest_.IsEmpty());
+  EXPECT_TRUE(checker->manifest_url_.is_empty());
+  EXPECT_TRUE(checker->icon_url_.is_empty());
+  EXPECT_EQ(nullptr, checker->icon_.get());
+  EXPECT_FALSE(checker->has_valid_webapp_manifest_);
+  EXPECT_FALSE(checker->has_service_worker_);
+
+  EXPECT_EQ(checker->ideal_icon_size_in_dp_, -1);
+  EXPECT_EQ(checker->minimum_icon_size_in_dp_, -1);
+
+  EXPECT_EQ(InstallableChecker::DORMANT, checker->status_);
+  EXPECT_EQ(NoErrorDetected, checker->manifest_error_);
+  EXPECT_EQ(NoErrorDetected, checker->valid_webapp_manifest_error_);
+  EXPECT_EQ(NoErrorDetected, checker->service_worker_error_);
+  EXPECT_EQ(NoErrorDetected, checker->icon_error_);
+  EXPECT_TRUE(checker->tasks_.empty());
+  EXPECT_TRUE(checker->pending_tasks_.empty());
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest, CheckNoManifest) {
+  // Ensure that a page with no manifest returns the appropriate error and with
+  // null fields for everything.
+  base::RunLoop run_loop;
+  std::unique_ptr<CallbackTester> tester(
+      new CallbackTester(run_loop.QuitClosure()));
+
+  NavigateAndRunInstallableChecker(tester.get(), GetManifestParams(),
+                                   "/banners/no_manifest_test_page.html");
+  run_loop.Run();
+
+  // If there is no manifest, everything should be empty.
+  EXPECT_TRUE(tester->manifest().IsEmpty());
+  EXPECT_TRUE(tester->manifest_url().is_empty());
+  EXPECT_TRUE(tester->icon_url().is_empty());
+  EXPECT_EQ(nullptr, tester->icon());
+  EXPECT_FALSE(tester->has_valid_webapp_manifest());
+  EXPECT_FALSE(tester->has_service_worker());
+  EXPECT_EQ(NoManifest, tester->error_code());
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest, CheckManifest404) {
+  base::RunLoop run_loop;
+  std::unique_ptr<CallbackTester> tester(
+      new CallbackTester(run_loop.QuitClosure()));
+
+  NavigateAndRunInstallableChecker(tester.get(), GetManifestParams(),
+                                   "/banners/manifest_bad_link.html");
+  run_loop.Run();
+
+  // The installable checker should return a manifest URL even if it 404s.
+  // However, the check should fail with a ManifestEmpty error.
+  EXPECT_TRUE(tester->manifest().IsEmpty());
+
+  EXPECT_FALSE(tester->manifest_url().is_empty());
+  EXPECT_TRUE(tester->icon_url().is_empty());
+  EXPECT_EQ(nullptr, tester->icon());
+  EXPECT_FALSE(tester->has_valid_webapp_manifest());
+  EXPECT_FALSE(tester->has_service_worker());
+  EXPECT_EQ(ManifestEmpty, tester->error_code());
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest, CheckManifestOnly) {
+  // Verify that asking for just the manifest works as expected.
+  base::RunLoop run_loop;
+  std::unique_ptr<CallbackTester> tester(
+      new CallbackTester(run_loop.QuitClosure()));
+
+  NavigateAndRunInstallableChecker(tester.get(), GetManifestParams(),
+                                   "/banners/manifest_test_page.html");
+  run_loop.Run();
+
+  EXPECT_FALSE(tester->manifest().IsEmpty());
+  EXPECT_FALSE(tester->manifest_url().is_empty());
+
+  EXPECT_TRUE(tester->icon_url().is_empty());
+  EXPECT_EQ(nullptr, tester->icon());
+  EXPECT_FALSE(tester->has_valid_webapp_manifest());
+  EXPECT_FALSE(tester->has_service_worker());
+  EXPECT_EQ(NoErrorDetected, tester->error_code());
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest,
+                       CheckInstallableParamsDefaultConstructor) {
+  // Verify that using InstallableParams' default constructor is equivalent to
+  // just asking for the manifest alone.
+  base::RunLoop run_loop;
+  std::unique_ptr<CallbackTester> tester(
+      new CallbackTester(run_loop.QuitClosure()));
+
+  InstallableParams params;
+  NavigateAndRunInstallableChecker(tester.get(), params,
+                                   "/banners/manifest_test_page.html");
+  run_loop.Run();
+
+  EXPECT_FALSE(tester->manifest().IsEmpty());
+  EXPECT_FALSE(tester->manifest_url().is_empty());
+
+  EXPECT_TRUE(tester->icon_url().is_empty());
+  EXPECT_EQ(nullptr, tester->icon());
+  EXPECT_FALSE(tester->has_valid_webapp_manifest());
+  EXPECT_FALSE(tester->has_service_worker());
+  EXPECT_EQ(NoErrorDetected, tester->error_code());
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest,
+                       CheckManifestWithOnlyRelatedApplications) {
+  // This page has a manifest with only related applications specified. Asking
+  // for just the manifest should succeed.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    NavigateAndRunInstallableChecker(tester.get(), GetManifestParams(),
+                                     "/banners/play_app_test_page.html");
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_TRUE(tester->manifest().prefer_related_applications);
+
+    EXPECT_TRUE(tester->icon_url().is_empty());
+    EXPECT_EQ(nullptr, tester->icon());
+    EXPECT_FALSE(tester->has_valid_webapp_manifest());
+    EXPECT_FALSE(tester->has_service_worker());
+    EXPECT_EQ(NoErrorDetected, tester->error_code());
+  }
+
+  // Ask whether it's valid for a webapp (but don't navigate). This should fail
+  // with StartUrlNotValid.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    RunInstallableChecker(tester.get(), GetValidManifestParams());
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_TRUE(tester->manifest().prefer_related_applications);
+
+    EXPECT_TRUE(tester->icon_url().is_empty());
+    EXPECT_EQ(nullptr, tester->icon());
+    EXPECT_FALSE(tester->has_valid_webapp_manifest());
+    EXPECT_FALSE(tester->has_service_worker());
+    EXPECT_EQ(StartUrlNotValid, tester->error_code());
+  }
+
+  // Ask for everything. This should still fail with StartUrlNotValid.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    RunInstallableChecker(tester.get(), GetWebAppParams());
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_TRUE(tester->manifest().prefer_related_applications);
+
+    EXPECT_TRUE(tester->icon_url().is_empty());
+    EXPECT_EQ(nullptr, tester->icon());
+    EXPECT_FALSE(tester->has_valid_webapp_manifest());
+    EXPECT_FALSE(tester->has_service_worker());
+    EXPECT_EQ(StartUrlNotValid, tester->error_code());
+  }
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest, CheckValidManifest) {
+  // Check for a manifest that's valid for a webapp.
+  base::RunLoop run_loop;
+  std::unique_ptr<CallbackTester> tester(
+      new CallbackTester(run_loop.QuitClosure()));
+
+  NavigateAndRunInstallableChecker(tester.get(), GetValidManifestParams(),
+                                   "/banners/manifest_test_page.html");
+  run_loop.Run();
+
+  EXPECT_FALSE(tester->manifest().IsEmpty());
+  EXPECT_FALSE(tester->manifest_url().is_empty());
+
+  EXPECT_TRUE(tester->icon_url().is_empty());
+  EXPECT_EQ(nullptr, tester->icon());
+
+  EXPECT_TRUE(tester->has_valid_webapp_manifest());
+  EXPECT_FALSE(tester->has_service_worker());
+  EXPECT_EQ(NoErrorDetected, tester->error_code());
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest, CheckManifestAndIcon) {
+  // Add to homescreen checks for manifest + icon.
+  base::RunLoop run_loop;
+  std::unique_ptr<CallbackTester> tester(
+      new CallbackTester(run_loop.QuitClosure()));
+
+  NavigateAndRunInstallableChecker(tester.get(), GetIconParams(),
+                                   "/banners/manifest_test_page.html");
+  run_loop.Run();
+
+  EXPECT_FALSE(tester->manifest().IsEmpty());
+  EXPECT_FALSE(tester->manifest_url().is_empty());
+
+  EXPECT_FALSE(tester->icon_url().is_empty());
+  EXPECT_NE(nullptr, tester->icon());
+
+  EXPECT_FALSE(tester->has_valid_webapp_manifest());
+  EXPECT_FALSE(tester->has_service_worker());
+  EXPECT_EQ(NoErrorDetected, tester->error_code());
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest, CheckWebapp) {
+  // Request everything.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    NavigateAndRunInstallableChecker(tester.get(), GetWebAppParams(),
+                                     "/banners/manifest_test_page.html");
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_TRUE(tester->has_valid_webapp_manifest());
+    EXPECT_TRUE(tester->has_service_worker());
+    EXPECT_FALSE(tester->icon_url().is_empty());
+    EXPECT_NE(nullptr, tester->icon());
+    EXPECT_EQ(NoErrorDetected, tester->error_code());
+
+    // Verify result state matches checker internal state.
+    InstallableChecker* checker = GetChecker();
+
+    EXPECT_FALSE(checker->manifest_.IsEmpty());
+    EXPECT_FALSE(checker->manifest_url_.is_empty());
+    EXPECT_TRUE(checker->has_valid_webapp_manifest_);
+    EXPECT_TRUE(checker->has_service_worker_);
+    EXPECT_FALSE(checker->icon_url_.is_empty());
+    EXPECT_NE(nullptr, checker->icon_.get());
+    EXPECT_TRUE(checker->HasFlag(InstallableChecker::MANIFEST_FETCHED));
+    EXPECT_TRUE(checker->HasFlag(InstallableChecker::MANIFEST_VALIDATED));
+    EXPECT_TRUE(checker->HasFlag(InstallableChecker::SERVICE_WORKER_CHECKED));
+    EXPECT_TRUE(checker->HasFlag(InstallableChecker::ICON_FETCHED));
+    EXPECT_EQ(48, checker->ideal_icon_size_in_dp_);
+    EXPECT_EQ(48, checker->minimum_icon_size_in_dp_);
+    EXPECT_EQ(NoErrorDetected, checker->processing_error_);
+    EXPECT_EQ(NoErrorDetected, checker->manifest_error_);
+    EXPECT_EQ(NoErrorDetected, checker->valid_webapp_manifest_error_);
+    EXPECT_EQ(NoErrorDetected, checker->service_worker_error_);
+    EXPECT_EQ(NoErrorDetected, checker->icon_error_);
+    EXPECT_TRUE(checker->tasks_.empty());
+    EXPECT_TRUE(checker->pending_tasks_.empty());
+  }
+
+  // Request everything again without navigating away. This should work fine.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    RunInstallableChecker(tester.get(), GetWebAppParams());
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_TRUE(tester->has_valid_webapp_manifest());
+    EXPECT_TRUE(tester->has_service_worker());
+    EXPECT_FALSE(tester->icon_url().is_empty());
+    EXPECT_NE(nullptr, tester->icon());
+    EXPECT_EQ(NoErrorDetected, tester->error_code());
+
+    // Verify result state matches checker internal state.
+    InstallableChecker* checker = GetChecker();
+
+    EXPECT_FALSE(checker->manifest_.IsEmpty());
+    EXPECT_FALSE(checker->manifest_url_.is_empty());
+    EXPECT_TRUE(checker->has_valid_webapp_manifest_);
+    EXPECT_TRUE(checker->has_service_worker_);
+    EXPECT_FALSE(checker->icon_url_.is_empty());
+    EXPECT_NE(nullptr, checker->icon_.get());
+    EXPECT_TRUE(checker->HasFlag(InstallableChecker::MANIFEST_FETCHED));
+    EXPECT_TRUE(checker->HasFlag(InstallableChecker::MANIFEST_VALIDATED));
+    EXPECT_TRUE(checker->HasFlag(InstallableChecker::SERVICE_WORKER_CHECKED));
+    EXPECT_TRUE(checker->HasFlag(InstallableChecker::ICON_FETCHED));
+    EXPECT_EQ(48, checker->ideal_icon_size_in_dp_);
+    EXPECT_EQ(48, checker->minimum_icon_size_in_dp_);
+    EXPECT_EQ(NoErrorDetected, checker->processing_error_);
+    EXPECT_EQ(NoErrorDetected, checker->manifest_error_);
+    EXPECT_EQ(NoErrorDetected, checker->valid_webapp_manifest_error_);
+    EXPECT_EQ(NoErrorDetected, checker->service_worker_error_);
+    EXPECT_EQ(NoErrorDetected, checker->icon_error_);
+    EXPECT_TRUE(checker->tasks_.empty());
+    EXPECT_TRUE(checker->pending_tasks_.empty());
+  }
+
+  {
+    // Check that a subsequent navigation resets state.
+    ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
+    InstallableChecker* checker = GetChecker();
+
+    EXPECT_TRUE(checker->manifest_.IsEmpty());
+    EXPECT_TRUE(checker->manifest_url_.is_empty());
+    EXPECT_FALSE(checker->has_service_worker_);
+    EXPECT_FALSE(checker->has_valid_webapp_manifest_);
+    EXPECT_TRUE(checker->icon_url_.is_empty());
+    EXPECT_EQ(nullptr, checker->icon_.get());
+    EXPECT_EQ(InstallableChecker::DORMANT, checker->status_);
+    EXPECT_FALSE(checker->HasFlag(InstallableChecker::MANIFEST_FETCHED));
+    EXPECT_FALSE(checker->HasFlag(InstallableChecker::MANIFEST_VALIDATED));
+    EXPECT_FALSE(checker->HasFlag(InstallableChecker::SERVICE_WORKER_CHECKED));
+    EXPECT_FALSE(checker->HasFlag(InstallableChecker::ICON_FETCHED));
+    EXPECT_EQ(-1, checker->ideal_icon_size_in_dp_);
+    EXPECT_EQ(-1, checker->minimum_icon_size_in_dp_);
+    EXPECT_EQ(NoErrorDetected, checker->processing_error_);
+    EXPECT_EQ(NoErrorDetected, checker->manifest_error_);
+    EXPECT_EQ(NoErrorDetected, checker->valid_webapp_manifest_error_);
+    EXPECT_EQ(NoErrorDetected, checker->service_worker_error_);
+    EXPECT_EQ(NoErrorDetected, checker->icon_error_);
+    EXPECT_TRUE(checker->tasks_.empty());
+    EXPECT_TRUE(checker->pending_tasks_.empty());
+  }
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest, CheckWebappInIframe) {
+  base::RunLoop run_loop;
+  std::unique_ptr<CallbackTester> tester(
+      new CallbackTester(run_loop.QuitClosure()));
+
+  NavigateAndRunInstallableChecker(tester.get(), GetWebAppParams(),
+                                   "/banners/iframe_test_page.html");
+  run_loop.Run();
+
+  // The installable checker should only retrieve items in the main frame;
+  // everything should be empty here.
+  EXPECT_TRUE(tester->manifest().IsEmpty());
+  EXPECT_TRUE(tester->manifest_url().is_empty());
+  EXPECT_TRUE(tester->icon_url().is_empty());
+  EXPECT_EQ(nullptr, tester->icon());
+  EXPECT_FALSE(tester->has_valid_webapp_manifest());
+  EXPECT_FALSE(tester->has_service_worker());
+  EXPECT_EQ(NoManifest, tester->error_code());
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest,
+                       CheckPageWithManifestAndNoServiceWorker) {
+  // Just fetch the manifest. This should have no error.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    NavigateAndRunInstallableChecker(
+        tester.get(), GetManifestParams(),
+        "/banners/manifest_no_service_worker.html");
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_FALSE(tester->has_valid_webapp_manifest());
+
+    EXPECT_TRUE(tester->icon_url().is_empty());
+    EXPECT_EQ(nullptr, tester->icon());
+    EXPECT_FALSE(tester->has_service_worker());
+    EXPECT_EQ(NoErrorDetected, tester->error_code());
+  }
+
+  // Fetch the full criteria should fail.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    RunInstallableChecker(tester.get(), GetWebAppParams());
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_TRUE(tester->has_valid_webapp_manifest());
+
+    EXPECT_TRUE(tester->icon_url().is_empty());
+    EXPECT_EQ(nullptr, tester->icon());
+    EXPECT_FALSE(tester->has_service_worker());
+    EXPECT_EQ(NoMatchingServiceWorker, tester->error_code());
+  }
+}
+
+IN_PROC_BROWSER_TEST_F(InstallableCheckerBrowserTest,
+                       CheckChangeInIconDimensions) {
+  // Verify that a follow-up request for an icon with a different size resets
+  // the icon state.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    NavigateAndRunInstallableChecker(tester.get(), GetWebAppParams(),
+                                     "/banners/manifest_test_page.html");
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_TRUE(tester->has_valid_webapp_manifest());
+    EXPECT_TRUE(tester->has_service_worker());
+    EXPECT_FALSE(tester->icon_url().is_empty());
+    EXPECT_NE(nullptr, tester->icon());
+    EXPECT_EQ(NoErrorDetected, tester->error_code());
+  }
+
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    // Dial up the icon size requirements to something that isn't available.
+    // This should now fail with NoIconMatchingRequirements.
+    InstallableParams params = GetWebAppParams();
+    params.ideal_icon_size_in_dp = 2000;
+    params.minimum_icon_size_in_dp = 2000;
+    RunInstallableChecker(tester.get(), params);
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_TRUE(tester->has_valid_webapp_manifest());
+    EXPECT_TRUE(tester->has_service_worker());
+    EXPECT_TRUE(tester->icon_url().is_empty());
+    EXPECT_EQ(nullptr, tester->icon());
+    EXPECT_EQ(NoIconMatchingRequirements, tester->error_code());
+  }
+
+  // Navigate and verify the reverse: an overly large icon requested first
+  // fails, but a smaller icon requested second passes.
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+
+    // This should fail with NoIconMatchingRequirements.
+    InstallableParams params = GetWebAppParams();
+    params.ideal_icon_size_in_dp = 2000;
+    params.minimum_icon_size_in_dp = 2000;
+    NavigateAndRunInstallableChecker(tester.get(), params,
+                                     "/banners/manifest_test_page.html");
+    run_loop.Run();
+
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_TRUE(tester->has_valid_webapp_manifest());
+    EXPECT_TRUE(tester->has_service_worker());
+    EXPECT_TRUE(tester->icon_url().is_empty());
+    EXPECT_EQ(nullptr, tester->icon());
+    EXPECT_EQ(NoIconMatchingRequirements, tester->error_code());
+  }
+
+  {
+    base::RunLoop run_loop;
+    std::unique_ptr<CallbackTester> tester(
+        new CallbackTester(run_loop.QuitClosure()));
+    RunInstallableChecker(tester.get(), GetWebAppParams());
+
+    run_loop.Run();
+
+    // The smaller icon requirements should allow this to pass.
+    EXPECT_FALSE(tester->manifest_url().is_empty());
+    EXPECT_FALSE(tester->manifest().IsEmpty());
+    EXPECT_TRUE(tester->has_valid_webapp_manifest());
+    EXPECT_TRUE(tester->has_service_worker());
+    EXPECT_FALSE(tester->icon_url().is_empty());
+    EXPECT_NE(nullptr, tester->icon());
+    EXPECT_EQ(NoErrorDetected, tester->error_code());
+  }
+}
+
+}  // namespace installable