Rename "icon" to "primary icon" in InstallableManager

chrome/browser/installable/installable_manager_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_manager.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 {
 
 InstallableParams GetManifestParams() {
   InstallableParams params;
   params.check_installable = false;
-  params.fetch_valid_icon = false;
+  params.fetch_valid_primary_icon = false;
   return params;
 }
 
 InstallableParams GetWebAppParams() {
   InstallableParams params = GetManifestParams();
-  params.ideal_icon_size_in_px = 144;
-  params.minimum_icon_size_in_px = 144;
+  params.ideal_primary_icon_size_in_px = 144;
+  params.minimum_primary_icon_size_in_px = 144;
   params.check_installable = true;
-  params.fetch_valid_icon = true;
+  params.fetch_valid_primary_icon = true;
   return params;
 }
 
 InstallableParams GetIconParams() {
   InstallableParams params = GetManifestParams();
-  params.ideal_icon_size_in_px = 144;
-  params.minimum_icon_size_in_px = 144;
-  params.fetch_valid_icon = true;
+  params.ideal_primary_icon_size_in_px = 144;
+  params.minimum_primary_icon_size_in_px = 144;
+  params.fetch_valid_primary_icon = true;
   return params;
 }
 
 }  // anonymous namespace
 
 class CallbackTester {
  public:
   explicit CallbackTester(base::Closure quit_closure)
       : quit_closure_(quit_closure) { }
 
   void OnDidFinishInstallableCheck(const InstallableData& data) {
     error_code_ = data.error_code;
     manifest_url_ = data.manifest_url;
     manifest_ = data.manifest;
-    icon_url_ = data.icon_url;
-    if (data.icon)
-      icon_.reset(new SkBitmap(*data.icon));
+    icon_url_ = data.primary_icon_url;
+    if (data.primary_icon)
+      icon_.reset(new SkBitmap(*data.primary_icon));
     is_installable_ = data.is_installable;
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure_);
   }
 
   InstallableStatusCode 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 is_installable() const { return is_installable_; }
@@ skipping 18 matching lines @@
   void Run() {
     manager_->GetData(params_,
                       base::Bind(&NestedCallbackTester::OnDidFinishFirstCheck,
                                  base::Unretained(this)));
   }
 
   void OnDidFinishFirstCheck(const InstallableData& data) {
     error_code_ = data.error_code;
     manifest_url_ = data.manifest_url;
     manifest_ = data.manifest;
-    icon_url_ = data.icon_url;
-    if (data.icon)
-      icon_.reset(new SkBitmap(*data.icon));
+    icon_url_ = data.primary_icon_url;
+    if (data.primary_icon)
+      icon_.reset(new SkBitmap(*data.primary_icon));
     is_installable_ = data.is_installable;
 
     manager_->GetData(params_,
                       base::Bind(&NestedCallbackTester::OnDidFinishSecondCheck,
                                  base::Unretained(this)));
   }
 
   void OnDidFinishSecondCheck(const InstallableData& data) {
     EXPECT_EQ(error_code_, data.error_code);
     EXPECT_EQ(manifest_url_, data.manifest_url);
-    EXPECT_EQ(icon_url_, data.icon_url);
-    EXPECT_EQ(icon_.get(), data.icon);
+    EXPECT_EQ(icon_url_, data.primary_icon_url);
+    EXPECT_EQ(icon_.get(), data.primary_icon);
     EXPECT_EQ(is_installable_, data.is_installable);
     EXPECT_EQ(manifest_.IsEmpty(), data.manifest.IsEmpty());
     EXPECT_EQ(manifest_.start_url, data.manifest.start_url);
     EXPECT_EQ(manifest_.display, data.manifest.display);
     EXPECT_EQ(manifest_.name, data.manifest.name);
     EXPECT_EQ(manifest_.short_name, data.manifest.short_name);
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure_);
   }
 
@@ skipping 221 matching lines @@
   }
 
   // Ask for a different size icon. This should fail with START_URL_NOT_VALID
   // since we won't have a cached icon error.
   {
     base::RunLoop run_loop;
     std::unique_ptr<CallbackTester> tester(
         new CallbackTester(run_loop.QuitClosure()));
 
     InstallableParams params = GetWebAppParams();
-    params.ideal_icon_size_in_px = 96;
-    params.minimum_icon_size_in_px = 96;
+    params.ideal_primary_icon_size_in_px = 96;
+    params.minimum_primary_icon_size_in_px = 96;
     RunInstallableManager(tester.get(), params);
     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->is_installable());
@@ skipping 202 matching lines @@
   }
 
   {
     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_px = 2000;
-    params.minimum_icon_size_in_px = 2000;
+    params.ideal_primary_icon_size_in_px = 2000;
+    params.minimum_primary_icon_size_in_px = 2000;
     RunInstallableManager(tester.get(), params);
     run_loop.Run();
 
     EXPECT_FALSE(tester->manifest_url().is_empty());
     EXPECT_FALSE(tester->manifest().IsEmpty());
     EXPECT_TRUE(tester->is_installable());
     EXPECT_TRUE(tester->icon_url().is_empty());
     EXPECT_EQ(nullptr, tester->icon());
     EXPECT_EQ(NO_ACCEPTABLE_ICON, 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_px = 2000;
-    params.minimum_icon_size_in_px = 2000;
+    params.ideal_primary_icon_size_in_px = 2000;
+    params.minimum_primary_icon_size_in_px = 2000;
     NavigateAndRunInstallableManager(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->is_installable());
     EXPECT_TRUE(tester->icon_url().is_empty());
     EXPECT_EQ(nullptr, tester->icon());
     EXPECT_EQ(NO_ACCEPTABLE_ICON, tester->error_code());
@@ skipping 21 matching lines @@
                        CheckNestedCallsToGetData) {
   // Verify that we can call GetData while in a callback from GetData.
   base::RunLoop run_loop;
   InstallableParams params = GetWebAppParams();
   std::unique_ptr<NestedCallbackTester> tester(
       new NestedCallbackTester(GetManager(), params, run_loop.QuitClosure()));
 
   tester->Run();
   run_loop.Run();
 }