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/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/service_manager/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 =
-    LAZY_INSTANCE_INITIALIZER;
+int gTimeDeltaInDaysForTesting = 0;
 
 // 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 15 matching lines @@
 
 namespace banners {
 
 // static
 void AppBannerManager::DisableSecureSchemeCheckForTesting() {
   gDisableSecureCheckForTesting = true;
 }
 
 // static
 base::Time AppBannerManager::GetCurrentTime() {
-  return base::Time::Now() + gTimeDeltaForTesting.Get();
+  return base::Time::Now() +
+         base::TimeDelta::FromDays(gTimeDeltaInDaysForTesting);
 }
 
 // static
 void AppBannerManager::SetTimeDeltaForTesting(int days) {
-  gTimeDeltaForTesting.Get() = base::TimeDelta::FromDays(days);
+  gTimeDeltaInDaysForTesting = days;
 }
 
 // static
 void AppBannerManager::SetEngagementWeights(double direct_engagement,
                                             double indirect_engagement) {
   AppBannerSettingsHelper::SetEngagementWeights(direct_engagement,
                                                 indirect_engagement);
 }
 
 // static
@@ skipping 34 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 when we request a new banner.
+  if (binding_.is_bound())
+    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(&controller_));
+
+  controller_->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_)
-    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