Fall back to legacy add to homescreen behavior on non-GMS device or GMS isn't availabe.

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 36 matching lines @@
 // 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
 // WebApkInstaller::StartUpdateUsingDownloadedWebApk() and
-// WebApkInstaller::HasGooglePlayWebApkInstallDelegate() and
+// WebApkInstaller::CanUseGooglePlayInstallService() and
 // WebApkInstaller::InstallOrUpdateWebApkFromGooglePlay() are stubbed out.
 class TestWebApkInstaller : public WebApkInstaller {
  public:
   TestWebApkInstaller(content::BrowserContext* browser_context,
                       const ShortcutInfo& shortcut_info,
                       const SkBitmap& shortcut_icon,
-                      bool has_google_play_webapk_install_delegate)
+                      bool can_use_google_play_install_service)
       : WebApkInstaller(browser_context, shortcut_info, shortcut_icon),
-        has_google_play_webapk_install_delegate_(
-            has_google_play_webapk_install_delegate) {}
+        can_use_google_play_install_service_(
+            can_use_google_play_install_service) {}
 
   bool StartInstallingDownloadedWebApk(
       JNIEnv* env,
       const base::android::ScopedJavaLocalRef<jstring>& file_path,
       const base::android::ScopedJavaLocalRef<jstring>& package_name) override {
     PostTaskToRunSuccessCallback();
     return true;
   }
 
   bool StartUpdateUsingDownloadedWebApk(
       JNIEnv* env,
       const base::android::ScopedJavaLocalRef<jstring>& file_path) override {
     return true;
   }
 
-  bool HasGooglePlayWebApkInstallDelegate() override {
-    return has_google_play_webapk_install_delegate_;
+  bool CanUseGooglePlayInstallService() override {
+    return can_use_google_play_install_service_;
   }
 
   bool InstallOrUpdateWebApkFromGooglePlay(const std::string& package_name,
                                            int version,
                                            const std::string& token) override {
     PostTaskToRunSuccessCallback();
     return true;
   }
 
   void PostTaskToRunSuccessCallback() {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&TestWebApkInstaller::OnSuccess, base::Unretained(this)));
   }
 
  private:
-  // Whether the Google Play install delegate is available.
-  bool has_google_play_webapk_install_delegate_;
+  // Whether the Google Play Service can be used and the install delegate is
+  // available.
+  bool can_use_google_play_install_service_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebApkInstaller);
 };
 
 // Runs the WebApkInstaller installation process/update and blocks till done.
 class WebApkInstallerRunner {
  public:
   WebApkInstallerRunner(content::BrowserContext* browser_context,
                         const GURL& best_icon_url)
       : browser_context_(browser_context),
         best_icon_url_(best_icon_url),
-        has_google_play_webapk_install_delegate_(false) {}
+        can_use_google_play_install_service_(false) {}
 
   ~WebApkInstallerRunner() {}
 
-  void SetHasGooglePlayWebApkInstallDelegate(bool has_delegate) {
-    has_google_play_webapk_install_delegate_ = has_delegate;
+  void SetCanUseGooglePlayInstallService(
+      bool can_use_google_play_install_service) {
+    can_use_google_play_install_service_ = can_use_google_play_install_service;
   }
 
   void RunInstallWebApk() {
     WebApkInstaller::InstallAsyncForTesting(
         CreateWebApkInstaller(),
         base::Bind(&WebApkInstallerRunner::OnCompleted,
                    base::Unretained(this)));
     Run();
   }
 
@@ skipping 14 matching lines @@
     Run();
   }
 
   WebApkInstaller* CreateWebApkInstaller() {
     ShortcutInfo info(GURL::EmptyGURL());
     info.best_icon_url = best_icon_url_;
 
     // WebApkInstaller owns itself.
     WebApkInstaller* installer =
         new TestWebApkInstaller(browser_context_, info, SkBitmap(),
-                                has_google_play_webapk_install_delegate_);
+                                can_use_google_play_install_service_);
     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();
   }
 
   content::BrowserContext* browser_context_;
 
   // The Web Manifest's 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_;
 
-  // Whether the Google Play install delegate is available.
-  bool has_google_play_webapk_install_delegate_;
+  // Whether Google Play Service can be used and the install delegate are

[pkotwicz, 2017/01/17 02:20:41]

Nit: are -> is

[Xi Han, 2017/01/17 14:36:07]

Done.

+  // available.
+  bool can_use_google_play_install_service_;
 
   DISALLOW_COPY_AND_ASSIGN(WebApkInstallerRunner);
 };
 
 // Builds a webapk::WebApkResponse with |download_url| as the WebAPK download
 // URL.
 std::unique_ptr<net::test_server::HttpResponse> BuildValidWebApkResponse(
     const GURL& download_url) {
   std::unique_ptr<webapk::WebApkResponse> response_proto(
       new webapk::WebApkResponse);
@@ skipping 224 matching lines @@
 // Test update succeeding.
 TEST_F(WebApkInstallerTest, UpdateSuccess) {
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunUpdateWebApk();
   EXPECT_TRUE(runner->success());
 }
 
 // Test installation succeeds using Google Play.
 TEST_F(WebApkInstallerTest, InstallFromGooglePlaySuccess) {
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
-  runner->SetHasGooglePlayWebApkInstallDelegate(true);
+  runner->SetCanUseGooglePlayInstallService(true);
   runner->RunInstallWebApk();
   EXPECT_TRUE(runner->success());
 }
 
 // When there is no Web Manifest available for a site, an empty |best_icon_url|
 // is used to build a WebApk update request. Tests the request can be built
 // properly.
 TEST_F(WebApkInstallerTest, BuildWebApkProtoWhenManifestIsObsolete) {
   GURL icon_url_1 = test_server()->GetURL("/icon1.png");
   GURL icon_url_2 = test_server()->GetURL("/icon2.png");
@@ skipping 55 matching lines @@
     icons[i] = manifest.icons(i);
 
   EXPECT_EQ(best_icon_url.spec(), icons[0].src());
   EXPECT_EQ(best_icon_murmur2_hash, icons[0].hash());
   EXPECT_TRUE(icons[0].has_image_data());
 
   EXPECT_EQ(icon_url_1.spec(), icons[1].src());
   EXPECT_EQ(icon_murmur2_hash_1, icons[1].hash());
   EXPECT_FALSE(icons[1].has_image_data());
 }