Remove untrusted sources installation flow.

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 44 matching lines @@
 // WebApkInstaller subclass where
 // WebApkInstaller::StartInstallingDownloadedWebApk() and
 // WebApkInstaller::StartUpdateUsingDownloadedWebApk() 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 can_use_google_play_install_service)
+                      bool can_install_webapks)
       : WebApkInstaller(browser_context, shortcut_info, shortcut_icon),
-        can_use_google_play_install_service_(
-            can_use_google_play_install_service) {}
+        can_install_webapks_(can_install_webapks) {}
 
-  void InstallDownloadedWebApk(
-      JNIEnv* env,
-      const base::android::ScopedJavaLocalRef<jstring>& file_path,
-      const base::android::ScopedJavaLocalRef<jstring>& package_name) override {
+  bool CanInstallWebApks() override { return can_install_webapks_; }
+
+  void InstallOrUpdateWebApk(const std::string& package_name,
+                             int version,
+                             const std::string& token) override {
     PostTaskToRunSuccessCallback();
   }
 
-  void UpdateUsingDownloadedWebApk(
-      JNIEnv* env,
-      const base::android::ScopedJavaLocalRef<jstring>& file_path) override {
-    PostTaskToRunSuccessCallback();
-  }
-
-  bool CanUseGooglePlayInstallService() override {
-    return can_use_google_play_install_service_;
-  }
-
-  void InstallOrUpdateWebApkFromGooglePlay(const std::string& package_name,
-                                           int version,
-                                           const std::string& token) override {
-    PostTaskToRunSuccessCallback();
-  }
-
   void PostTaskToRunSuccessCallback() {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&TestWebApkInstaller::OnResult, base::Unretained(this),
                    WebApkInstallResult::SUCCESS));
   }
 
  private:
   // Whether the Google Play Services can be used and the install delegate is
   // available.
-  bool can_use_google_play_install_service_;
+  bool can_install_webapks_;
 
   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_primary_icon_url)
       : browser_context_(browser_context),
         best_primary_icon_url_(best_primary_icon_url),
-        can_use_google_play_install_service_(false) {}
+        can_install_webapks_(true) {}
 
   ~WebApkInstallerRunner() {}
 
-  void SetCanUseGooglePlayInstallService(
-      bool can_use_google_play_install_service) {
-    can_use_google_play_install_service_ = can_use_google_play_install_service;
+  void SetCanInstallWebApks(bool can_install_webapks) {
+    can_install_webapks_ = can_install_webapks;
   }
 
   void RunInstallWebApk() {
     WebApkInstaller::InstallAsyncForTesting(
         CreateWebApkInstaller(), base::Bind(&WebApkInstallerRunner::OnCompleted,
                                             base::Unretained(this)));
     Run();
   }
 
   void RunUpdateWebApk() {
     const int kWebApkVersion = 1;
 
     std::map<std::string, std::string> icon_url_to_murmur2_hash{
         {best_primary_icon_url_.spec(), "0"}};
 
     WebApkInstaller::UpdateAsyncForTesting(
         CreateWebApkInstaller(), kDownloadedWebApkPackageName, kWebApkVersion,
         icon_url_to_murmur2_hash, false /* is_manifest_stale */,
         base::Bind(&WebApkInstallerRunner::OnCompleted,
                    base::Unretained(this)));
     Run();
   }
 
   WebApkInstaller* CreateWebApkInstaller() {
     ShortcutInfo info(GURL::EmptyGURL());
     info.best_primary_icon_url = best_primary_icon_url_;
 
     // WebApkInstaller owns itself.
-    WebApkInstaller* installer =
-        new TestWebApkInstaller(browser_context_, info, SkBitmap(),
-                                can_use_google_play_install_service_);
+    WebApkInstaller* installer = new TestWebApkInstaller(
+        browser_context_, info, SkBitmap(), can_install_webapks_);
     installer->SetTimeoutMs(100);
     return installer;
   }
 
   void Run() {
     base::RunLoop run_loop;
     on_completed_callback_ = run_loop.QuitClosure();
     run_loop.Run();
   }
 
@@ skipping 11 matching lines @@
 
   // The Web Manifest's icon URL.
   const GURL best_primary_icon_url_;
 
   // Called after the installation process has succeeded or failed.
   base::Closure on_completed_callback_;
 
   // The result of the installation process.
   WebApkInstallResult result_;
 
-  // Whether Google Play Service can be used and the install delegate is
-  // available.
-  bool can_use_google_play_install_service_;
+  // Whether the device supports installation of WebApks.
+  bool can_install_webapks_;
 
   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 168 matching lines @@
 // 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);
 
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunInstallWebApk();
   EXPECT_EQ(WebApkInstallResult::FAILURE, runner->result());
 }
 
-// Test that installation fails if the WebAPK download times out.
-TEST_F(WebApkInstallerTest, WebApkDownloadTimesOut) {
-  GURL download_url = test_server()->GetURL("/slow?1000");
-  SetWebApkResponseBuilder(base::Bind(&BuildValidWebApkResponse, download_url));
-
-  std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
-  runner->RunInstallWebApk();
-  EXPECT_EQ(WebApkInstallResult::FAILURE, runner->result());
-}
-
-// Test that installation fails if the WebAPK download fails.
-TEST_F(WebApkInstallerTest, WebApkDownloadFails) {
-  GURL download_url = test_server()->GetURL("/nocontent");
-  SetWebApkResponseBuilder(base::Bind(&BuildValidWebApkResponse, download_url));
-
-  std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
-  runner->RunInstallWebApk();
-  EXPECT_EQ(WebApkInstallResult::FAILURE, runner->result());
-}
-
 namespace {
 
 // Returns an HttpResponse which cannot be parsed as a webapk::WebApkResponse.
 std::unique_ptr<net::test_server::HttpResponse>
 BuildUnparsableWebApkResponse() {
   std::unique_ptr<net::test_server::BasicHttpResponse> response(
       new net::test_server::BasicHttpResponse());
   response->set_code(net::HTTP_OK);
   response->set_content("😀");
   return std::move(response);
@@ skipping 26 matching lines @@
 // - The most up to date version of the WebAPK on the server is identical to the
 //   one installed on the client.
 TEST_F(WebApkInstallerTest, UpdateSuccessWithEmptyDownloadUrlInResponse) {
   SetWebApkResponseBuilder(base::Bind(&BuildValidWebApkResponse, GURL()));
 
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunUpdateWebApk();
   EXPECT_EQ(WebApkInstallResult::SUCCESS, runner->result());
 }
 
-// Test installation succeeds using Google Play.
-TEST_F(WebApkInstallerTest, InstallFromGooglePlaySuccess) {
-  std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
-  runner->SetCanUseGooglePlayInstallService(true);
-  runner->RunInstallWebApk();
-  EXPECT_EQ(WebApkInstallResult::SUCCESS, runner->result());
-}
-
 // When there is no Web Manifest available for a site, an empty
 // |best_primary_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");
   std::string icon_murmur2_hash_1 = "1";
   std::string icon_murmur2_hash_2 = "2";
   std::map<std::string, std::string> icon_url_to_murmur2_hash;
   icon_url_to_murmur2_hash[icon_url_1.spec()] = icon_murmur2_hash_1;
@@ skipping 51 matching lines @@
     icons[i] = manifest.icons(i);
 
   EXPECT_EQ(best_primary_icon_url.spec(), icons[0].src());
   EXPECT_EQ(best_primary_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());
 }
+
+TEST_F(WebApkInstallerTest, FailsWhenInstallDisabled) {
+  std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
+  runner->SetCanInstallWebApks(false);
+  runner->RunInstallWebApk();
+  EXPECT_EQ(WebApkInstallResult::FAILURE, runner->result());
+}