Convert app banners to use Mojo.

chrome/browser/banners/app_banner_manager.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_manager.h"
 
+#include <algorithm>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/banners/app_banner_metrics.h"
 #include "chrome/browser/banners/app_banner_settings_helper.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
-#include "chrome/browser/installable/installable_logging.h"
-#include "chrome/browser/installable/installable_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/render_messages.h"
 #include "components/rappor/rappor_utils.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/origin_util.h"
-#include "third_party/WebKit/public/platform/modules/app_banner/WebAppBannerPromptReply.h"
+#include "services/shell/public/cpp/interface_provider.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
 namespace {
 
 bool gDisableSecureCheckForTesting = false;
 int gCurrentRequestID = -1;
 base::LazyInstance<base::TimeDelta> gTimeDeltaForTesting =

[benwells, 2016/10/12 03:00:17]

Unrelated nit: you could get rid of this LazyInstance by just have int
gDaysDeltaForTesting and constructing the TimeDelta as needed.

[dominickn, 2016/10/13 00:18:15]

Done.

     LAZY_INSTANCE_INITIALIZER;
 
 // Returns |size_in_px| in dp, i.e. divided by the current device scale factor.
 int ConvertIconSizeFromPxToDp(int size_in_px) {
   return size_in_px /
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
 }
 
 InstallableParams ParamsToGetManifest() {
   return InstallableParams();
@@ skipping 76 matching lines @@
   if (!content::IsOriginSecure(validated_url) &&
       !gDisableSecureCheckForTesting) {
     ReportStatus(contents, NOT_FROM_SECURE_ORIGIN);
     Stop();
     return;
   }
 
   if (validated_url_.is_empty())
     validated_url_ = validated_url;
 
+  // Any existing binding is invalid if we re-request the banner.
+  if (binding_.is_bound())

[benwells, 2016/10/12 03:00:17]

Why does the service have to be invalidated after each request?

[dominickn, 2016/10/13 00:18:15]

AppBannerManager only ever manages one in-flight request at a time (we stop in
RequestAppBanner if we're already checking this URL). So if we've issued a
binding to an event previously, that binding is invalid once we get here.

+    binding_.Close();
+
   manager_->GetData(
       ParamsToGetManifest(),
       base::Bind(&AppBannerManager::OnDidGetManifest, GetWeakPtr()));
 }
 
+void AppBannerManager::SendBannerAccepted(int request_id) {
+  if (request_id != gCurrentRequestID)
+    return;
+
+  DCHECK(event_.is_bound());
+  event_->BannerAccepted(GetBannerType());
+}
+
+void AppBannerManager::SendBannerDismissed(int request_id) {
+  if (request_id != gCurrentRequestID)
+    return;
+
+  DCHECK(event_.is_bound());
+  event_->BannerDismissed();
+}
+
 base::Closure AppBannerManager::FetchWebappSplashScreenImageCallback(
     const std::string& webapp_id) {
   return base::Closure();
 }
 
 AppBannerManager::AppBannerManager(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       SiteEngagementObserver(nullptr),
       manager_(nullptr),
       event_request_id_(-1),
+      binding_(this),
       is_active_(false),
       banner_request_queued_(false),
       load_finished_(false),
       was_canceled_by_page_(false),
       page_requested_prompt_(false),
       is_debug_mode_(false),
       need_to_log_status_(false),
       weak_factory_(this) {
   // Ensure the InstallableManager exists since we have a hard dependency on it.
   InstallableManager::CreateForWebContents(web_contents);
@@ skipping 165 matching lines @@
 
   // Given all of the other checks that have been made, the only possible reason
   // for stopping now is that the app has been added to the homescreen.
   if (!IsDebugMode() && !CheckIfShouldShowBanner()) {
     Stop();
     return;
   }
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_CREATED);
   event_request_id_ = ++gCurrentRequestID;
-  content::RenderFrameHost* frame = web_contents()->GetMainFrame();
-  frame->Send(new ChromeViewMsg_AppBannerPromptRequest(
-      frame->GetRoutingID(), event_request_id_, GetBannerType()));
+
+  web_contents()->GetMainFrame()->GetRemoteInterfaces()->GetInterface(
+      mojo::GetProxy(&client_));
+
+  client_->BannerPromptRequest(
+      binding_.CreateInterfacePtrAndBind(), mojo::GetProxy(&event_),
+      GetBannerType(),
+      base::Bind(&AppBannerManager::OnBannerPromptReply, GetWeakPtr()));
 }
 
 void AppBannerManager::DidStartNavigation(content::NavigationHandle* handle) {
   if (!handle->IsInMainFrame())
     return;
 
   load_finished_ = false;
   if (AppBannerSettingsHelper::ShouldUseSiteEngagementScore() &&
       GetSiteEngagementService() == nullptr) {
     // Ensure that we are observing the site engagement service on navigation
@@ skipping 108 matching lines @@
   }
 
   // If we are in debug mode, AppBannerSettingsHelper::ShouldShowBanner must
   // return NO_ERROR_DETECTED (bypass flag is set) or we must not have entered
   // this method.
   DCHECK(!IsDebugMode());
   ReportStatus(web_contents(), code);
   return false;
 }
 
-bool AppBannerManager::OnMessageReceived(
-    const IPC::Message& message,
-    content::RenderFrameHost* render_frame_host) {
-  bool handled = true;
-
-  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(AppBannerManager, message, render_frame_host)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AppBannerPromptReply,
-                        OnBannerPromptReply)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_RequestShowAppBanner,
-                        OnRequestShowAppBanner)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  return handled;
-}
-
 void AppBannerManager::OnBannerPromptReply(
-    content::RenderFrameHost* render_frame_host,
-    int request_id,
-    blink::WebAppBannerPromptReply reply,
-    std::string referrer) {
+    blink::mojom::AppBannerPromptReply reply,
+    const std::string& referrer) {
   content::WebContents* contents = web_contents();
-  if (request_id != event_request_id_)

[benwells, 2016/10/12 03:00:17]

I assume this check here was to guarantee something to prevent races. How come
it is safe to delete it now?

[dominickn, 2016/10/13 00:18:15]

This is implicitly handled because OnBannerPromptReply can only be called as the
reply from calling client_->BannerPromptRequest, which sets event_request_id_
for this request. If we terminate the banner flow before the reply comes back,
Stop() calls InvalidateWeakPtrs which will prevent this method from being run.

Previously with IPCs, it was possible for the IPC to still be sent even though
the AppBannerManager had moved on to a new request because there wasn't a way to
tell the renderer to stop.

It may even be possible to get rid of the event_request_ids entirely from the
browser side too, though I don't want to do that in this CL.

-    return;
-
   // The renderer might have requested the prompt to be canceled.
   // They may request that it is redisplayed later, so don't Stop() here.
   // However, log that the cancelation was requested, so Stop() can be
   // called if a redisplay isn't asked for.
   //
   // We use the additional page_requested_prompt_ variable because the redisplay
   // request may be received *before* the Cancel prompt reply (e.g. if redisplay
   // is requested in the beforeinstallprompt event handler).
   referrer_ = referrer;
-  if (reply == blink::WebAppBannerPromptReply::Cancel &&
+  if (reply == blink::mojom::AppBannerPromptReply::CANCEL &&
       !page_requested_prompt_) {
     TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_PREVENT_DEFAULT_CALLED);
     was_canceled_by_page_ = true;
     return;
   }
 
   // If we haven't yet returned, but either of |was_canceled_by_page_| or
   // |page_requested_prompt_| is true, the page has requested a delayed showing
   // of the prompt. Otherwise, the prompt was never canceled by the page.
   if (was_canceled_by_page_ || page_requested_prompt_) {
@@ skipping 10 matching lines @@
   DCHECK(!manifest_url_.is_empty());
   DCHECK(!manifest_.IsEmpty());
   DCHECK(!icon_url_.is_empty());
   DCHECK(icon_.get());
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_COMPLETE);
   ShowBanner();
   is_active_ = false;
 }
 
-void AppBannerManager::OnRequestShowAppBanner(
-    content::RenderFrameHost* render_frame_host,
-    int request_id) {
+void AppBannerManager::DisplayAppBanner() {
   if (was_canceled_by_page_) {
     // Simulate a non-canceled OnBannerPromptReply to show the delayed banner.
     // Don't reset |was_canceled_by_page_| yet for metrics purposes.
-    OnBannerPromptReply(render_frame_host, request_id,
-                        blink::WebAppBannerPromptReply::None, referrer_);
+    OnBannerPromptReply(blink::mojom::AppBannerPromptReply::NONE, referrer_);
   } else {
     // Log that the prompt request was made for when we get the prompt reply.
     page_requested_prompt_ = true;
   }
 }
 
 }  // namespace banners