[Android:WebAPK] Don't add webapp to homescreen if WebAPK install times out part 1/3

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>
 
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/shortcut_info.h"
 #include "chrome/browser/android/webapk/webapk.pb.h"
+#include "chrome/browser/android/webapk/webapk_install_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 47 matching lines @@
 
   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::OnSuccess, base::Unretained(this)));
+        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_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebApkInstaller);
 };
 
@@ skipping 45 matching lines @@
     installer->SetTimeoutMs(100);
     return installer;
   }
 
   void Run() {
     base::RunLoop run_loop;
     on_completed_callback_ = run_loop.QuitClosure();
     run_loop.Run();
   }
 
-  bool success() { return success_; }
+  WebApkInstallResult result() { return result_; }
 
  private:
-  void OnCompleted(bool success,
+  void OnCompleted(WebApkInstallResult result,
                    bool relax_updates,
                    const std::string& webapk_package) {
-    success_ = success;
+    result_ = result;
     on_completed_callback_.Run();
   }
 
   content::BrowserContext* browser_context_;
 
   // 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_;
 
-  // Whether the installation process succeeded.
-  bool success_;
+  // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(WebApkInstallerRunner);
 };
 
 // Builds a webapk::WebApkResponse with |download_url| as the WebAPK download
 // URL.
@@ skipping 147 matching lines @@
   // 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());
+  EXPECT_EQ(WebApkInstallResult::SUCCESS, runner->result());
 }
 
 // Test that installation fails if fetching the bitmap at the best primary icon
 // URL times out. In a perfect world the fetch would never time out because the
 // bitmap at the best primary icon URL should be in the HTTP cache.
 TEST_F(WebApkInstallerTest, BestPrimaryIconUrlDownloadTimesOut) {
   GURL best_primary_icon_url = test_server()->GetURL("/slow?1000");
   SetBestPrimaryIconUrl(best_primary_icon_url);
 
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunInstallWebApk();
-  EXPECT_FALSE(runner->success());
+  EXPECT_EQ(WebApkInstallResult::FAILURE, runner->result());
 }
 
 // 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_FALSE(runner->success());
+  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_FALSE(runner->success());
+  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_FALSE(runner->success());
+  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);
 }
 
 }  // anonymous namespace
 
 // Test that an HTTP response which cannot be parsed as a webapk::WebApkResponse
 // is handled properly.
 TEST_F(WebApkInstallerTest, UnparsableCreateWebApkResponse) {
   SetWebApkResponseBuilder(base::Bind(&BuildUnparsableWebApkResponse));
 
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunInstallWebApk();
-  EXPECT_FALSE(runner->success());
+  EXPECT_EQ(WebApkInstallResult::FAILURE, runner->result());
 }
 
 // Test update succeeding.
 TEST_F(WebApkInstallerTest, UpdateSuccess) {
   std::unique_ptr<WebApkInstallerRunner> runner = CreateWebApkInstallerRunner();
   runner->RunUpdateWebApk();
-  EXPECT_TRUE(runner->success());
+  EXPECT_EQ(WebApkInstallResult::SUCCESS, runner->result());
 }
 
 // Test that an update suceeds if the WebAPK server returns a HTTP response with
 // an empty download URL. The WebAPK server sends an empty download URL when:
 // - The server is unable to update the WebAPK in the way that the client
 //   requested.
 // AND
 // - 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_TRUE(runner->success());
+  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_TRUE(runner->success());
+  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";
@@ skipping 53 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());
 }