Call AddToHomescreenDataFetcher::Observer callbacks when manifest fetch times out

chrome/browser/android/webapps/add_to_homescreen_data_fetcher.cc

 // Copyright 2015 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/webapps/add_to_homescreen_data_fetcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 55 matching lines @@
 }
 
 }  // namespace
 
 AddToHomescreenDataFetcher::AddToHomescreenDataFetcher(
     content::WebContents* web_contents,
     int ideal_icon_size_in_dp,
     int minimum_icon_size_in_dp,
     int ideal_splash_image_size_in_dp,
     int minimum_splash_image_size_in_dp,
-    bool check_installable,
+    bool check_webapk_compatibility,
     Observer* observer)
     : WebContentsObserver(web_contents),
       weak_observer_(observer),
       shortcut_info_(GetShortcutUrl(web_contents->GetBrowserContext(),
                                     web_contents->GetLastCommittedURL())),
       data_timeout_timer_(false, false),
       ideal_icon_size_in_dp_(ideal_icon_size_in_dp),
       minimum_icon_size_in_dp_(minimum_icon_size_in_dp),
       ideal_splash_image_size_in_dp_(ideal_splash_image_size_in_dp),
       minimum_splash_image_size_in_dp_(minimum_splash_image_size_in_dp),
-      check_installable_(check_installable),
-      is_waiting_for_installable_check_(check_installable),
+      check_webapk_compatibility_(check_webapk_compatibility),
       is_waiting_for_web_application_info_(true),
+      is_installable_check_complete_(false),
       is_icon_saved_(false),
       is_ready_(false) {
   DCHECK(minimum_icon_size_in_dp <= ideal_icon_size_in_dp);
   DCHECK(minimum_splash_image_size_in_dp <= ideal_splash_image_size_in_dp);
 
   // Send a message to the renderer to retrieve information about the page.
   Send(new ChromeViewMsg_GetWebApplicationInfo(routing_id()));
 }
 
 base::Closure AddToHomescreenDataFetcher::FetchSplashScreenImageCallback(
@@ skipping 46 matching lines @@
 
   InstallableManager::CreateForWebContents(web_contents());
   InstallableManager* manager =
       InstallableManager::FromWebContents(web_contents());
   DCHECK(manager);
 
   // Kick off a timeout for downloading data. If we haven't finished within the
   // timeout, fall back to using a dynamically-generated launcher icon.
   data_timeout_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(4000),
-      base::Bind(&AddToHomescreenDataFetcher::OnFaviconFetched, this,
-                  favicon_base::FaviconRawBitmapResult()));
+      base::Bind(&AddToHomescreenDataFetcher::OnDataTimedout, this));
 
   manager->GetData(
       ParamsToPerformInstallableCheck(ideal_icon_size_in_dp_,
                                       minimum_icon_size_in_dp_,
-                                      check_installable_),
+                                      check_webapk_compatibility_),
       base::Bind(&AddToHomescreenDataFetcher::OnDidPerformInstallableCheck,
                  this));
 }
 
 AddToHomescreenDataFetcher::~AddToHomescreenDataFetcher() {
   DCHECK(!weak_observer_);
 }
 
 bool AddToHomescreenDataFetcher::OnMessageReceived(
     const IPC::Message& message) {
   if (!is_waiting_for_web_application_info_)
     return false;
 
   bool handled = true;
 
   IPC_BEGIN_MESSAGE_MAP(AddToHomescreenDataFetcher, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_DidGetWebApplicationInfo,
                         OnDidGetWebApplicationInfo)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
+void AddToHomescreenDataFetcher::OnDataTimedout() {
+  if (!web_contents() || !weak_observer_)
+    return;
+
+  if (!is_installable_check_complete_) {
+    is_installable_check_complete_ = true;
+    if (check_webapk_compatibility_)
+      weak_observer_->OnDidDetermineWebApkCompatibility(false);
+    weak_observer_->OnUserTitleAvailable(base::string16());
+  }
+
+  if (!is_icon_saved_)
+    CreateLauncherIcon(SkBitmap());
+}
 
 void AddToHomescreenDataFetcher::OnDidPerformInstallableCheck(
     const InstallableData& data) {
   if (!web_contents() || !weak_observer_)
     return;
 
-  if (check_installable_) {
-    is_waiting_for_installable_check_ = false;
+  is_installable_check_complete_ = true;
+
+  if (check_webapk_compatibility_)
     weak_observer_->OnDidDetermineWebApkCompatibility(data.is_installable);
-  }
 
   if (!data.manifest.IsEmpty()) {
     content::RecordAction(
         base::UserMetricsAction("webapps.AddShortcut.Manifest"));
     shortcut_info_.UpdateFromManifest(data.manifest);
     shortcut_info_.manifest_url = data.manifest_url;
   }
 
   // Save the splash screen URL for the later download.
   splash_screen_url_ = ManifestIconSelector::FindBestMatchingIcon(
       data.manifest.icons, ideal_splash_image_size_in_dp_,
       minimum_splash_image_size_in_dp_);
 
   weak_observer_->OnUserTitleAvailable(shortcut_info_.user_title);
 
   if (data.icon) {
     shortcut_info_.icon_url = data.icon_url;
 
-    // base::Bind copies the arguments internally, so it is safe to pass it
-    // data.icon (which is not owned by us).
-    content::BrowserThread::GetBlockingPool()
-        ->PostWorkerTaskWithShutdownBehavior(
-            FROM_HERE,
-            base::Bind(
-                &AddToHomescreenDataFetcher::CreateLauncherIconInBackground,
-                this, *(data.icon)),
-            base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+    CreateLauncherIcon(*(data.icon));
     return;
   }
 
   FetchFavicon();
 }
 
 void AddToHomescreenDataFetcher::FetchFavicon() {
   if (!web_contents() || !weak_observer_)
     return;
 
-  if (check_installable_ && is_waiting_for_installable_check_) {
-    is_waiting_for_installable_check_ = false;
-    weak_observer_->OnDidDetermineWebApkCompatibility(false);
-  }
-
   // Grab the best, largest icon we can find to represent this bookmark.
   // TODO(dfalcantara): Try combining with the new BookmarksHandler once its
   //                    rewrite is further along.
   std::vector<int> icon_types{
       favicon_base::FAVICON,
       favicon_base::TOUCH_PRECOMPOSED_ICON | favicon_base::TOUCH_ICON};
 
   favicon::FaviconService* favicon_service =
       FaviconServiceFactory::GetForProfile(
           Profile::FromBrowserContext(web_contents()->GetBrowserContext()),
@@ skipping 30 matching lines @@
   SkBitmap raw_icon;
   if (bitmap_result.is_valid()) {
     gfx::PNGCodec::Decode(bitmap_result.bitmap_data->front(),
                           bitmap_result.bitmap_data->size(), &raw_icon);
   }
 
   shortcut_info_.icon_url = bitmap_result.icon_url;
   CreateLauncherIconInBackground(raw_icon);
 }
 
+void AddToHomescreenDataFetcher::CreateLauncherIcon(const SkBitmap& raw_icon) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    content::BrowserThread::GetBlockingPool()
+        ->PostWorkerTaskWithShutdownBehavior(
+            FROM_HERE,
+            base::Bind(
+                &AddToHomescreenDataFetcher::CreateLauncherIconInBackground,
+                this, raw_icon),
+            base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+}
+
 void AddToHomescreenDataFetcher::CreateLauncherIconInBackground(
     const SkBitmap& raw_icon) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   SkBitmap icon;
   bool is_generated = false;
   if (weak_observer_) {
     icon = weak_observer_->FinalizeLauncherIconInBackground(
         raw_icon, shortcut_info_.url, &is_generated);
   }
 
   if (is_generated)
     shortcut_info_.icon_url = GURL();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&AddToHomescreenDataFetcher::NotifyObserver, this, icon));
 }
 
 void AddToHomescreenDataFetcher::NotifyObserver(const SkBitmap& icon) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!web_contents() || !weak_observer_ || is_icon_saved_)
     return;
 
   is_icon_saved_ = true;
   shortcut_icon_ = icon;
   is_ready_ = true;
   weak_observer_->OnDataAvailable(shortcut_info_, shortcut_icon_);
 }