Allow banners to trigger on sites which don't register a service worker onload.

chrome/browser/installable/installable_manager.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/bind.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/manifest/manifest_icon_downloader.h"
 #include "chrome/browser/manifest/manifest_icon_selector.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ssl/security_state_tab_helper.h"
 #include "components/security_state/core/security_state.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_handle.h"
-#include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/base/url_util.h"
 #include "third_party/WebKit/public/platform/WebDisplayMode.h"
 
 using IconPurpose = content::Manifest::Icon::IconPurpose;
 
 namespace {
 
 const char kPngExtension[] = ".png";
 
@@ skipping 41 matching lines @@
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(InstallableManager);
 
 struct InstallableManager::ManifestProperty {
   InstallableStatusCode error = NO_ERROR_DETECTED;
   GURL url;
   content::Manifest manifest;
   bool fetched = false;
 };
 
-struct InstallableManager::InstallableProperty {
+struct InstallableManager::ValidManifestProperty {
   InstallableStatusCode error = NO_ERROR_DETECTED;
-  bool installable = false;
+  bool is_valid = false;
   bool fetched = false;
 };
 
+struct InstallableManager::ServiceWorkerProperty {
+  InstallableStatusCode error = NO_ERROR_DETECTED;
+  bool has_worker = false;
+  bool is_waiting = false;
+  bool fetched = false;
+};
+
 struct InstallableManager::IconProperty {
   IconProperty() :
     error(NO_ERROR_DETECTED), url(), icon(), fetched(false) { }
   IconProperty(IconProperty&& other) = default;
   IconProperty& operator=(IconProperty&& other) = default;
 
   InstallableStatusCode error = NO_ERROR_DETECTED;
   GURL url;
   std::unique_ptr<SkBitmap> icon;
   bool fetched;
 
  private:
   // This class contains a std::unique_ptr and therefore must be move-only.
   DISALLOW_COPY_AND_ASSIGN(IconProperty);
 };
 
 InstallableManager::InstallableManager(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
-      manifest_(new ManifestProperty()),
-      installable_(new InstallableProperty()),
+      manifest_(base::MakeUnique<ManifestProperty>()),
+      valid_manifest_(base::MakeUnique<ValidManifestProperty>()),
+      worker_(base::MakeUnique<ServiceWorkerProperty>()),
+      service_worker_context_(nullptr),
       page_status_(InstallabilityCheckStatus::NOT_STARTED),
       menu_open_count_(0),
       menu_item_add_to_homescreen_count_(0),
       is_active_(false),
       is_pwa_check_complete_(false),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  // This is null in unit tests.
+  if (web_contents) {
+    content::StoragePartition* storage_partition =
+        content::BrowserContext::GetStoragePartition(
+            Profile::FromBrowserContext(web_contents->GetBrowserContext()),
+            web_contents->GetSiteInstance());
+    DCHECK(storage_partition);
 
-InstallableManager::~InstallableManager() = default;
+    service_worker_context_ = storage_partition->GetServiceWorkerContext();
+    service_worker_context_->AddObserver(this);
+  }
+}
+
+InstallableManager::~InstallableManager() {
+  // Null in unit tests.
+  if (service_worker_context_)
+    service_worker_context_->RemoveObserver(this);
+}
 
 // static
 bool InstallableManager::IsContentSecure(content::WebContents* web_contents) {
   if (!web_contents)
     return false;
 
   // Whitelist localhost. Check the VisibleURL to match what the
   // SecurityStateTabHelper looks at.
   if (net::IsLocalhost(web_contents->GetVisibleURL().HostNoBrackets()))
     return true;
@@ skipping 98 matching lines @@
 
 void InstallableManager::SetIconFetched(const IconParams& params) {
   icons_[params].fetched = true;
 }
 
 InstallableStatusCode InstallableManager::GetErrorCode(
     const InstallableParams& params) {
   if (manifest_->error != NO_ERROR_DETECTED)
     return manifest_->error;
 
-  if (params.check_installable && installable_->error != NO_ERROR_DETECTED)
-    return installable_->error;
+  if (params.check_installable) {
+    if (valid_manifest_->error != NO_ERROR_DETECTED)
+      return valid_manifest_->error;
+    if (worker_->error != NO_ERROR_DETECTED)
+      return worker_->error;
+  }
 
   if (params.fetch_valid_primary_icon) {
     IconProperty& icon = icons_[ParamsForPrimaryIcon(params)];
     if (icon.error != NO_ERROR_DETECTED)
       return icon.error;
   }
 
   if (params.fetch_valid_badge_icon) {
     IconProperty& icon = icons_[ParamsForBadgeIcon(params)];
 
     // If the error is NO_ACCEPTABLE_ICON, there is no icon suitable as a badge
     // in the manifest. Ignore this case since we only want to fail the check if
     // there was a suitable badge icon specified and we couldn't fetch it.
     if (icon.error != NO_ERROR_DETECTED && icon.error != NO_ACCEPTABLE_ICON)
       return icon.error;
   }
 
   return NO_ERROR_DETECTED;
 }
 
 InstallableStatusCode InstallableManager::manifest_error() const {
   return manifest_->error;
 }
 
-InstallableStatusCode InstallableManager::installable_error() const {
-  return installable_->error;
+InstallableStatusCode InstallableManager::valid_manifest_error() const {
+  return valid_manifest_->error;
 }
 
-void InstallableManager::set_installable_error(
+void InstallableManager::set_valid_manifest_error(
     InstallableStatusCode error_code) {
-  installable_->error = error_code;
+  valid_manifest_->error = error_code;
+}
+
+InstallableStatusCode InstallableManager::worker_error() const {
+  return worker_->error;
 }
 
 InstallableStatusCode InstallableManager::icon_error(
     const IconParams& icon_params) {
   return icons_[icon_params].error;
 }
 
 GURL& InstallableManager::icon_url(const IconParams& icon_params) {
   return icons_[icon_params].url;
 }
 
 const SkBitmap* InstallableManager::icon(const IconParams& icon_params) {
   return icons_[icon_params].icon.get();
 }
 
 content::WebContents* InstallableManager::GetWebContents() {
   content::WebContents* contents = web_contents();
   if (!contents || contents->IsBeingDestroyed())
     return nullptr;
   return contents;
 }
 
 bool InstallableManager::IsComplete(const InstallableParams& params) const {
   // Returns true if for all resources:
   //  a. the params did not request it, OR
   //  b. the resource has been fetched/checked.
   return manifest_->fetched &&
-         (!params.check_installable || installable_->fetched) &&
+         (!params.check_installable ||
+          (valid_manifest_->fetched && worker_->fetched)) &&
          (!params.fetch_valid_primary_icon ||
-             IsIconFetched(ParamsForPrimaryIcon(params))) &&
+          IsIconFetched(ParamsForPrimaryIcon(params))) &&
          (!params.fetch_valid_badge_icon ||
-             IsIconFetched(ParamsForBadgeIcon(params)));
+          IsIconFetched(ParamsForBadgeIcon(params)));
 }
 
 void InstallableManager::Reset() {
   // Prevent any outstanding callbacks to or from this object from being called.
   weak_factory_.InvalidateWeakPtrs();
   tasks_.clear();
   icons_.clear();
 
   // We may have reset prior to completion, in which case |menu_open_count_| or
   // |menu_item_add_to_homescreen_count_| might be nonzero and |page_status_| is
   // one of NOT_STARTED or NOT_COMPLETED. If we completed, then these values
   // cannot be anything except 0.
   is_pwa_check_complete_ = false;
 
   for (; menu_open_count_ > 0; --menu_open_count_)
     InstallableMetrics::RecordMenuOpenHistogram(page_status_);
 
   for (; menu_item_add_to_homescreen_count_ > 0;
        --menu_item_add_to_homescreen_count_) {
     InstallableMetrics::RecordMenuItemAddToHomescreenHistogram(page_status_);
   }
 
   page_status_ = InstallabilityCheckStatus::NOT_STARTED;
-  manifest_.reset(new ManifestProperty());
-  installable_.reset(new InstallableProperty());
+  manifest_ = base::MakeUnique<ManifestProperty>();
+  valid_manifest_ = base::MakeUnique<ValidManifestProperty>();
+  worker_ = base::MakeUnique<ServiceWorkerProperty>();
 
   is_active_ = false;
 }
 
 void InstallableManager::SetManifestDependentTasksComplete() {
   DCHECK(!tasks_.empty());
   const InstallableParams& params = tasks_[0].first;
 
-  installable_->fetched = true;
+  valid_manifest_->fetched = true;
+  worker_->fetched = true;
   SetIconFetched(ParamsForPrimaryIcon(params));
   SetIconFetched(ParamsForBadgeIcon(params));
 }
 
 void InstallableManager::RunCallback(const Task& task,
                                      InstallableStatusCode code) {
   const InstallableParams& params = task.first;
   IconProperty null_icon;
   IconProperty* primary_icon = &null_icon;
   IconProperty* badge_icon = &null_icon;
@@ skipping 43 matching lines @@
     tasks_.erase(tasks_.begin());
     StartNextTask();
     return;
   }
 
   if (!manifest_->fetched) {
     FetchManifest();
   } else if (params.fetch_valid_primary_icon &&
              !IsIconFetched(ParamsForPrimaryIcon(params))) {
     CheckAndFetchBestIcon(ParamsForPrimaryIcon(params));
-  } else if (params.check_installable && !installable_->fetched) {
+  } else if (params.check_installable && !valid_manifest_->fetched) {
     CheckInstallable();
+  } else if (params.check_installable && !worker_->fetched) {
+    CheckServiceWorker();
   } else if (params.fetch_valid_badge_icon &&
              !IsIconFetched(ParamsForBadgeIcon(params))) {
     CheckAndFetchBestIcon(ParamsForBadgeIcon(params));
   } else {
     NOTREACHED();
   }
 }
 
 void InstallableManager::FetchManifest() {
   DCHECK(!manifest_->fetched);
@@ skipping 18 matching lines @@
     SetManifestDependentTasksComplete();
   }
 
   manifest_->url = manifest_url;
   manifest_->manifest = manifest;
   manifest_->fetched = true;
   WorkOnTask();
 }
 
 void InstallableManager::CheckInstallable() {
-  DCHECK(!installable_->fetched);
+  DCHECK(!valid_manifest_->fetched);
   DCHECK(!manifest().IsEmpty());
 
-  if (IsManifestValidForWebApp(manifest())) {
-    CheckServiceWorker();
-  } else {
-    installable_->installable = false;
-    installable_->fetched = true;
-    WorkOnTask();
-  }
+  valid_manifest_->is_valid = IsManifestValidForWebApp(manifest());
+  valid_manifest_->fetched = true;
+  WorkOnTask();
 }
 
 bool InstallableManager::IsManifestValidForWebApp(
     const content::Manifest& manifest) {
   if (manifest.IsEmpty()) {
-    installable_->error = MANIFEST_EMPTY;
+    valid_manifest_->error = MANIFEST_EMPTY;
     return false;
   }
 
   if (!manifest.start_url.is_valid()) {
-    installable_->error = START_URL_NOT_VALID;
+    valid_manifest_->error = START_URL_NOT_VALID;
     return false;
   }
 
   if ((manifest.name.is_null() || manifest.name.string().empty()) &&
       (manifest.short_name.is_null() || manifest.short_name.string().empty())) {
-    installable_->error = MANIFEST_MISSING_NAME_OR_SHORT_NAME;
+    valid_manifest_->error = MANIFEST_MISSING_NAME_OR_SHORT_NAME;
     return false;
   }
 
   // TODO(dominickn,mlamouri): when Chrome supports "minimal-ui", it should be
   // accepted. If we accept it today, it would fallback to "browser" and make
   // this check moot. See https://crbug.com/604390.
   if (manifest.display != blink::kWebDisplayModeStandalone &&
       manifest.display != blink::kWebDisplayModeFullscreen) {
-    installable_->error = MANIFEST_DISPLAY_NOT_SUPPORTED;
+    valid_manifest_->error = MANIFEST_DISPLAY_NOT_SUPPORTED;
     return false;
   }
 
   if (!DoesManifestContainRequiredIcon(manifest)) {
-    installable_->error = MANIFEST_MISSING_SUITABLE_ICON;
+    valid_manifest_->error = MANIFEST_MISSING_SUITABLE_ICON;
     return false;
   }
 
   return true;
 }
 
 void InstallableManager::CheckServiceWorker() {
-  DCHECK(!installable_->fetched);
+  DCHECK(!worker_->fetched);
   DCHECK(!manifest().IsEmpty());
   DCHECK(manifest().start_url.is_valid());
 
-  content::WebContents* web_contents = GetWebContents();
-
   // Check to see if there is a single service worker controlling this page
   // and the manifest's start url.
-  content::StoragePartition* storage_partition =
-      content::BrowserContext::GetStoragePartition(
-          Profile::FromBrowserContext(web_contents->GetBrowserContext()),
-          web_contents->GetSiteInstance());
-  DCHECK(storage_partition);
-
-  storage_partition->GetServiceWorkerContext()->CheckHasServiceWorker(
-      web_contents->GetLastCommittedURL(), manifest().start_url,
+  service_worker_context_->CheckHasServiceWorker(
+      GetWebContents()->GetLastCommittedURL(), manifest().start_url,
       base::Bind(&InstallableManager::OnDidCheckHasServiceWorker,
                  weak_factory_.GetWeakPtr()));
 }
 
 void InstallableManager::OnDidCheckHasServiceWorker(
     content::ServiceWorkerCapability capability) {
   if (!GetWebContents())
     return;
 
   switch (capability) {
     case content::ServiceWorkerCapability::SERVICE_WORKER_WITH_FETCH_HANDLER:
-      installable_->installable = true;
+      worker_->has_worker = true;
       break;
     case content::ServiceWorkerCapability::SERVICE_WORKER_NO_FETCH_HANDLER:
-      installable_->installable = false;
-      installable_->error = NOT_OFFLINE_CAPABLE;
+      worker_->has_worker = false;
+      worker_->error = NOT_OFFLINE_CAPABLE;
       break;
     case content::ServiceWorkerCapability::NO_SERVICE_WORKER:
-      installable_->installable = false;
-      installable_->error = NO_MATCHING_SERVICE_WORKER;
+      InstallableParams& params = tasks_[0].first;
+      if (params.wait_for_worker) {
+        // Wait for ServiceWorkerContextObserver::OnRegistrationStored. Set the
+        // param |wait_for_worker| to false so we only wait once per task.
+        params.wait_for_worker = false;
+        worker_->is_waiting = true;
+        return;
+      }
+      worker_->has_worker = false;
+      worker_->error = NO_MATCHING_SERVICE_WORKER;
       break;
   }
 
-  installable_->fetched = true;
+  worker_->fetched = true;
   WorkOnTask();
 }
 
 void InstallableManager::CheckAndFetchBestIcon(const IconParams& params) {
   DCHECK(!manifest().IsEmpty());
 
   int ideal_icon_size_in_px = std::get<0>(params);
   int minimum_icon_size_in_px = std::get<1>(params);
   IconPurpose icon_purpose = std::get<2>(params);
 
@@ skipping 30 matching lines @@
   if (bitmap.drawsNothing()) {
     icon.error = NO_ICON_AVAILABLE;
   } else {
     icon.url = icon_url;
     icon.icon.reset(new SkBitmap(bitmap));
   }
 
   WorkOnTask();
 }
 
+void InstallableManager::OnRegistrationStored(const GURL& pattern) {
+  // We aren't currently waiting, so either:
+  //  a) we've already failed the check, or
+  //  b) we haven't yet called CheckHasServiceWorker.
+  if (!worker_->is_waiting || !content::ServiceWorkerContext::ScopeMatches(
+                                  pattern, manifest().start_url)) {
+    return;
+  }
+
+  // This will call CheckHasServiceWorker to check whether the service worker
+  // controls the start_url and if it has a fetch handler.
+  worker_->is_waiting = false;
+  WorkOnTask();
+}
+
 void InstallableManager::DidFinishNavigation(
     content::NavigationHandle* handle) {
   if (handle->IsInMainFrame() && handle->HasCommitted() &&
       !handle->IsSameDocument()) {
     Reset();
   }
 }
 
 void InstallableManager::WebContentsDestroyed() {
   Reset();
   Observe(nullptr);
 }
 
 const GURL& InstallableManager::manifest_url() const {
   return manifest_->url;
 }
 
 const content::Manifest& InstallableManager::manifest() const {
   return manifest_->manifest;
 }
 
 bool InstallableManager::is_installable() const {
-  return installable_->installable;
+  return valid_manifest_->is_valid && worker_->has_worker;
 }