Log messages regarding why app banners aren't displayed to the console

chrome/browser/banners/app_banner_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/banners/app_banner_data_fetcher.h"
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/banners/app_banner_debug_log.h"
 #include "chrome/browser/banners/app_banner_metrics.h"
 #include "chrome/browser/banners/app_banner_settings_helper.h"
 #include "chrome/browser/bitmap_fetcher/bitmap_fetcher.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/manifest/manifest_icon_selector.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/render_messages.h"
 #include "components/infobars/core/infobar.h"
 #include "components/rappor/rappor_utils.h"
@@ skipping 113 matching lines @@
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void AppBannerDataFetcher::OnBannerPromptReply(
     content::RenderFrameHost* render_frame_host,
     int request_id,
     blink::WebAppBannerPromptReply reply) {
   content::WebContents* web_contents = GetWebContents();
-  if (!is_active_ || !web_contents || request_id != event_request_id_) {
+  if (!CheckFetcherIsStillAlive(web_contents) ||
+      request_id != event_request_id_) {
     Cancel();
     return;
   }
 
   // The renderer might have requested the prompt to be canceled.
   if (reply == blink::WebAppBannerPromptReply::Cancel) {
+    OutputDeveloperNotShownMessage(web_contents, kRendererRequestCancel);
     Cancel();
     return;
   }
 
   // Definitely going to show the banner now.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnDecidedWhetherToShow(this, true));
 
   infobars::InfoBar* infobar = CreateBanner(app_icon_.get(), app_title_);
   if (infobar) {
@@ skipping 64 matching lines @@
       GetCurrentTime());
   rappor::SampleDomainAndRegistryFromGURL(g_browser_process->rappor_service(),
                                           event_name,
                                           web_contents->GetURL());
   banners::TrackDisplayEvent(DISPLAY_EVENT_CREATED);
 }
 
 void AppBannerDataFetcher::OnDidGetManifest(
     const content::Manifest& manifest) {
   content::WebContents* web_contents = GetWebContents();
-  if (!is_active_ || !web_contents || manifest.IsEmpty()) {
+  if (!CheckFetcherIsStillAlive(web_contents)) {
     Cancel();
     return;
   }
+  if (manifest.IsEmpty()) {
+    OutputDeveloperNotShownMessage(web_contents, kManifestEmpty);
+    Cancel();
+    return;
+  }
 
   if (manifest.prefer_related_applications &&
       manifest.related_applications.size()) {
     for (const auto& application : manifest.related_applications) {
       std::string platform = base::UTF16ToUTF8(application.platform.string());
       std::string id = base::UTF16ToUTF8(application.id.string());
       if (weak_delegate_->HandleNonWebApp(platform, application.url, id))
         return;
     }
   }
 
-  if (!IsManifestValidForWebApp(manifest)) {
+  if (!IsManifestValidForWebApp(manifest, web_contents)) {
     Cancel();
     return;
   }
 
   banners::TrackDisplayEvent(DISPLAY_EVENT_BANNER_REQUESTED);
 
   web_app_data_ = manifest;
   app_title_ = web_app_data_.name.string();
 
   // Check to see if there is a single service worker controlling this page
   // and the manifest's start url.
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   content::StoragePartition* storage_partition =
       content::BrowserContext::GetStoragePartition(
           profile, web_contents->GetSiteInstance());
   DCHECK(storage_partition);
 
   storage_partition->GetServiceWorkerContext()->CheckHasServiceWorker(
       validated_url_, manifest.start_url,
       base::Bind(&AppBannerDataFetcher::OnDidCheckHasServiceWorker,
                  this));
 }
 
 void AppBannerDataFetcher::OnDidCheckHasServiceWorker(
     bool has_service_worker) {
   content::WebContents* web_contents = GetWebContents();
-  if (!is_active_ || !web_contents) {
+  if (!CheckFetcherIsStillAlive(web_contents)) {
     Cancel();
     return;
   }
 
   if (has_service_worker) {
     // Create an infobar to promote the manifest's app.
     GURL icon_url =
         ManifestIconSelector::FindBestMatchingIcon(
             web_app_data_.icons,
             ideal_icon_size_,
             gfx::Screen::GetScreenFor(web_contents->GetNativeView()));
     if (!icon_url.is_empty()) {
       FetchIcon(icon_url);
       return;
     }
+    OutputDeveloperNotShownMessage(web_contents, kCannotDetermineBestIcon);
   } else {
     TrackDisplayEvent(DISPLAY_EVENT_LACKS_SERVICE_WORKER);
+    OutputDeveloperNotShownMessage(web_contents, kNoMatchingServiceWorker);
   }
 
   Cancel();
 }
 
 void AppBannerDataFetcher::OnFetchComplete(const GURL& url,
                                            const SkBitmap* icon) {
   if (is_active_)
     ShowBanner(icon);
 
   Release();
 }
 
 void AppBannerDataFetcher::ShowBanner(const SkBitmap* icon) {
   content::WebContents* web_contents = GetWebContents();
-  if (!is_active_ || !web_contents || !icon) {
+  if (!CheckFetcherIsStillAlive(web_contents)) {
+    Cancel();
+    return;
+  }
+  if (!icon) {
+    OutputDeveloperNotShownMessage(web_contents, kNoIconAvailable);
     Cancel();
     return;
   }
 
   RecordCouldShowBanner();
   if (!CheckIfShouldShowBanner()) {
+    // At this point, the only possible case is that the banner has been added
+    // to the homescreen, given all of the other checks that have been made.
+    OutputDeveloperNotShownMessage(web_contents, kBannerAlreadyAdded);
     Cancel();
     return;
   }
 
   app_icon_.reset(new SkBitmap(*icon));
   event_request_id_ = ++gCurrentRequestID;
   web_contents->GetMainFrame()->Send(
       new ChromeViewMsg_AppBannerPromptRequest(
           web_contents->GetMainFrame()->GetRoutingID(),
           event_request_id_,
@@ skipping 11 matching lines @@
 }
 
 bool AppBannerDataFetcher::CheckIfShouldShowBanner() {
   content::WebContents* web_contents = GetWebContents();
   DCHECK(web_contents);
 
   return AppBannerSettingsHelper::ShouldShowBanner(
       web_contents, validated_url_, GetAppIdentifier(), GetCurrentTime());
 }
 
+bool AppBannerDataFetcher::CheckFetcherIsStillAlive(
+    content::WebContents* web_contents) {
+  if (!is_active_) {
+    OutputDeveloperNotShownMessage(web_contents,
+                                   kUserNavigatedBeforeBannerShown);
+    return false;
+  }
+  if (!web_contents) {
+    return false; // We cannot show a message if |web_contents| is null
+  }
+  return true;
+}
+
 // static
 bool AppBannerDataFetcher::IsManifestValidForWebApp(
-    const content::Manifest& manifest) {
-  if (manifest.IsEmpty())
+    const content::Manifest& manifest,
+    content::WebContents* web_contents) {
+  if (manifest.IsEmpty()) {
+    OutputDeveloperNotShownMessage(web_contents, kManifestEmpty);
     return false;
-  if (!manifest.start_url.is_valid())
+  }
+  if (!manifest.start_url.is_valid()) {
+    OutputDeveloperNotShownMessage(web_contents, kStartURLNotValid);
     return false;
-  if (manifest.name.is_null() && manifest.short_name.is_null())
+  }
+  if (manifest.name.is_null() && manifest.short_name.is_null()) {
+    OutputDeveloperNotShownMessage(web_contents,
+                                   kManifestMissingNameOrShortName);
     return false;
-  if (!DoesManifestContainRequiredIcon(manifest))
+  }
+  if (!DoesManifestContainRequiredIcon(manifest)) {
+    OutputDeveloperNotShownMessage(web_contents, kManifestMissingSuitableIcon);
     return false;
+  }
   return true;
 }
 
 }  // namespace banners