Don't block InstallableManager::GetData calls when waiting for a service worker.

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/profiles/profile.h"
@@ skipping 67 matching lines @@
 
 struct InstallableManager::ValidManifestProperty {
   InstallableStatusCode error = NO_ERROR_DETECTED;
   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;
@@ skipping 190 matching lines @@
 
 void InstallableManager::set_valid_manifest_error(
     InstallableStatusCode error_code) {
   valid_manifest_->error = error_code;
 }
 
 InstallableStatusCode InstallableManager::worker_error() const {
   return worker_->error;
 }
 
-bool InstallableManager::worker_waiting() const {
-  return worker_->is_waiting;
-}
-
 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) {
@@ skipping 17 matching lines @@
          (!params.fetch_valid_primary_icon ||
           IsIconFetched(ParamsForPrimaryIcon(params))) &&
          (!params.fetch_valid_badge_icon ||
           IsIconFetched(ParamsForBadgeIcon(params)));
 }
 
 void InstallableManager::Reset() {
   // Prevent any outstanding callbacks to or from this object from being called.
   weak_factory_.InvalidateWeakPtrs();
   tasks_.clear();
+  paused_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_);
@@ skipping 191 matching lines @@
 
   switch (capability) {
     case content::ServiceWorkerCapability::SERVICE_WORKER_WITH_FETCH_HANDLER:
       worker_->has_worker = true;
       break;
     case content::ServiceWorkerCapability::SERVICE_WORKER_NO_FETCH_HANDLER:
       worker_->has_worker = false;
       worker_->error = NOT_OFFLINE_CAPABLE;
       break;
     case content::ServiceWorkerCapability::NO_SERVICE_WORKER:
-      InstallableParams& params = tasks_[0].first;
+      Task& task = tasks_[0];
+      InstallableParams& params = task.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;
         OnWaitingForServiceWorker();
+        paused_tasks_.push_back(task);
+        tasks_.erase(tasks_.begin());
+        StartNextTask();
         return;
       }
       worker_->has_worker = false;
       worker_->error = NO_MATCHING_SERVICE_WORKER;
       break;
   }
 
   worker_->fetched = true;
   WorkOnTask();
 }
@@ skipping 39 matching lines @@
     icon.error = NO_ICON_AVAILABLE;
   } else {
     icon.url = icon_url;
     icon.icon.reset(new SkBitmap(bitmap));
   }
 
   WorkOnTask();
 }
 
 void InstallableManager::OnRegistrationStored(const GURL& pattern) {
-  // If we aren't currently waiting, either:
+  // If we don't have any paused tasks, that means:
   //   a) we've already failed the check, or
   //   b) we haven't yet called CheckHasServiceWorker.
   // Otherwise if the scope doesn't match we keep waiting.
-  if (!worker_->is_waiting || !content::ServiceWorkerContext::ScopeMatches(
-                                  pattern, manifest().start_url)) {
+  if (paused_tasks_.empty() || !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();
+  // Unpause the paused tasks.
+  for (const auto& task : paused_tasks_)
+    tasks_.push_back(task);
+  paused_tasks_.clear();
+
+  // Start the pipeline again if it is not running. This will call
+  // CheckHasServiceWorker to check if the SW has a fetch handler. Otherwise,
+  // adding the tasks to the end of the active queue is sufficient.
+  if (!is_active_) {
+    is_active_ = true;
+    StartNextTask();
+  }
 }
 
 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 valid_manifest_->is_valid && worker_->has_worker;
 }