Send all of the icon URLs listed in Web Manifest to WebAPK Server.

chrome/browser/android/webapk/webapk_installer_unittest.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/android/webapk/webapk_installer.h"
 
 #include <jni.h>
 #include <memory>
 #include <string>
 
@@ skipping 29 matching lines @@
 const base::FilePath::CharType kTestDataDir[] =
     FILE_PATH_LITERAL("chrome/test/data");
 
 // Mock field trial name and field trial group to use for "WebApks" feature.
 const char kFieldTrialName[] = "MockFieldTrial";
 const char kFieldTrialGroup[] = "MockFieldTrialGroup";
 
 // URL of mock WebAPK server.
 const char* kServerUrl = "/webapkserver/";
 
-// Icon URL from Web Manifest. We use a random file in the test data directory.
-// Since WebApkInstaller does not try to decode the file as an image it is OK
-// that the file is not an image.
-const char* kIconUrl = "/simple.html";
+// The best icon URL from Web Manifest. We use a random file in the test data
+// directory. Since WebApkInstaller does not try to decode the file as an image
+// it is OK that the file is not an image.
+const char* kBestIconUrl = "/simple.html";
 
 // URL of file to download from the WebAPK server. We use a random file in the
 // test data directory.
 const char* kDownloadUrl = "/simple.html";
 
 // The package name of the downloaded WebAPK.
 const char* kDownloadedWebApkPackageName = "party.unicode";
 
 // WebApkInstaller subclass where
 // WebApkInstaller::StartInstallingDownloadedWebApk() and
@@ skipping 24 matching lines @@
         base::Bind(&TestWebApkInstaller::OnSuccess, base::Unretained(this)));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestWebApkInstaller);
 };
 
 // Runs the WebApkInstaller installation process/update and blocks till done.
 class WebApkInstallerRunner {
  public:
-  explicit WebApkInstallerRunner(const GURL& icon_url)
+  explicit WebApkInstallerRunner(const GURL& best_icon_url)
       : url_request_context_getter_(new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get())),
-        icon_url_(icon_url) {}
+        best_icon_url_(best_icon_url) {}
   ~WebApkInstallerRunner() {}
 
   void RunInstallWebApk() {
     WebApkInstaller* installer = CreateWebApkInstaller();
 
     installer->InstallAsyncWithURLRequestContextGetter(
         url_request_context_getter_.get(),
         base::Bind(&WebApkInstallerRunner::OnCompleted,
                    base::Unretained(this)));
     Run();
@@ skipping 10 matching lines @@
         base::Bind(&WebApkInstallerRunner::OnCompleted, base::Unretained(this)),
         kIconMurmur2Hash,
         kDownloadedWebApkPackageName,
         kWebApkVersion);
 
     Run();
   }
 
   WebApkInstaller* CreateWebApkInstaller() {
     ShortcutInfo info(GURL::EmptyGURL());
-    info.icon_url = icon_url_;
+    info.best_icon_url = best_icon_url_;
 
     // WebApkInstaller owns itself.
     WebApkInstaller* installer = new TestWebApkInstaller(info, SkBitmap());
     installer->SetTimeoutMs(100);
     return installer;
   }
 
   void Run() {
     base::RunLoop run_loop;
     on_completed_callback_ = run_loop.QuitClosure();
     run_loop.Run();
   }
 
   bool success() { return success_; }
 
  private:
   void OnCompleted(bool success, const std::string& webapk_package) {
     success_ = success;
     on_completed_callback_.Run();
   }
 
   scoped_refptr<net::TestURLRequestContextGetter>
       url_request_context_getter_;
 
   // The Web Manifest's icon URL.
-  const GURL icon_url_;
+  const GURL best_icon_url_;
 
   // Called after the installation process has succeeded or failed.
   base::Closure on_completed_callback_;
 
   // Whether the installation process succeeded.
   bool success_;
 
   DISALLOW_COPY_AND_ASSIGN(WebApkInstallerRunner);
 };
 
@@ skipping 41 matching lines @@
     std::unique_ptr<base::FeatureList> feature_list =
         base::MakeUnique<base::FeatureList>();
     feature_list->RegisterFieldTrialOverride(
         chrome::android::kWebApks.name,
         base::FeatureList::OVERRIDE_ENABLE_FEATURE, field_trial);
     scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
 
     SetDefaults();
   }
 
-  // Sets the Web Manifest's icon URL.
-  void SetIconUrl(const GURL& icon_url) { icon_url_ = icon_url; }
+  // Sets the best Web Manifest's icon URL.
+  void SetBestIconUrl(const GURL& best_icon_url) {
+    best_icon_url_ = best_icon_url;
+  }
 
   // Sets the URL to send the webapk::CreateWebApkRequest to. WebApkInstaller
   // should fail if the URL is not |kServerUrl|.
   void SetWebApkServerUrl(const GURL& server_url) {
     variations::testing::ClearAllVariationParams();
     std::map<std::string, std::string> params;
     params["ServerUrl"] = server_url.spec();
     ASSERT_TRUE(variations::AssociateVariationParams(kFieldTrialName,
                                                      kFieldTrialGroup, params));
   }
 
   // Sets the function that should be used to build the response to the
   // WebAPK creation request.
   void SetWebApkResponseBuilder(const WebApkResponseBuilder& builder) {
     webapk_response_builder_ = builder;
   }
 
   std::unique_ptr<WebApkInstallerRunner> CreateWebApkInstallerRunner() {
     return std::unique_ptr<WebApkInstallerRunner>(
-        new WebApkInstallerRunner(icon_url_));
+        new WebApkInstallerRunner(best_icon_url_));
   }
 
   net::test_server::EmbeddedTestServer* test_server() { return &test_server_; }
 
  private:
   // Sets default configuration for running WebApkInstaller.
   void SetDefaults() {
-    GURL icon_url = test_server_.GetURL(kIconUrl);
-    SetIconUrl(icon_url);
+    GURL best_icon_url = test_server_.GetURL(kBestIconUrl);
+    SetBestIconUrl(best_icon_url);
     GURL server_url = test_server_.GetURL(kServerUrl);
     SetWebApkServerUrl(server_url);
     GURL download_url = test_server_.GetURL(kDownloadUrl);
     SetWebApkResponseBuilder(
         base::Bind(&BuildValidWebApkResponse, download_url));
   }
 
   std::unique_ptr<net::test_server::HttpResponse> HandleWebApkRequest(
       const net::test_server::HttpRequest& request) {
     return (request.relative_url == kServerUrl)
                ? webapk_response_builder_.Run()
                : std::unique_ptr<net::test_server::HttpResponse>();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   net::EmbeddedTestServer test_server_;
 
   std::unique_ptr<base::FieldTrialList> field_trial_list_;
   base::test::ScopedFeatureList scoped_feature_list_;
 
   // Web Manifest's icon URL.
-  GURL icon_url_;
+  GURL best_icon_url_;
 
   // Builds response to the WebAPK creation request.
   WebApkResponseBuilder webapk_response_builder_;
 
   DISALLOW_COPY_AND_ASSIGN(WebApkInstallerTest);
 };
 
 // Test installation succeeding.
 TEST_F(WebApkInstallerTest, Success) {
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunInstallWebApk();
   EXPECT_TRUE(runner->success());
 }
 
-// Test that installation fails if fetching the bitmap at the icon URL times
-// out. In a perfect world the fetch would never time out because the bitmap at
-// the icon URL should be in the HTTP cache.
-TEST_F(WebApkInstallerTest, IconUrlDownloadTimesOut) {
-  GURL icon_url = test_server()->GetURL("/slow?1000");
-  SetIconUrl(icon_url);
+// Test that installation fails if fetching the bitmap at the best icon URL
+// times out. In a perfect world the fetch would never time out because the
+// bitmap at the best icon URL should be in the HTTP cache.
+TEST_F(WebApkInstallerTest, BestIconUrlDownloadTimesOut) {
+  GURL best_icon_url = test_server()->GetURL("/slow?1000");
+  SetBestIconUrl(best_icon_url);
 
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunInstallWebApk();
   EXPECT_FALSE(runner->success());
 }
 
 // Test that installation fails if the WebAPK creation request times out.
 TEST_F(WebApkInstallerTest, CreateWebApkRequestTimesOut) {
   GURL server_url = test_server()->GetURL("/slow?1000");
   SetWebApkServerUrl(server_url);
@@ skipping 46 matching lines @@
   runner->RunInstallWebApk();
   EXPECT_FALSE(runner->success());
 }
 
 // Test update succeeding.
 TEST_F(WebApkInstallerTest, UpdateSuccess) {
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunUpdateWebApk();
   EXPECT_TRUE(runner->success());
 }