[iOS] Move UI delegate and observer out of OverlayPresenter.

This CL creates a separate file for OverlayPresenter::UIDelegate
(renamed to OverlayPresentationContext).  This was done because the
presentation context will need to support observation so that the
presenter can be aware of when it has a coordinator in which to present
overlay UI.  The class was renamed because it seems like an anti-pattern
for a delegate to support observation.

This CL also moves OverlayPresenter::Observer to a separate file for
consistency.

Bug: 941745
Change-Id: I92208a28a84a450d3a00aa08c7dfbf546bb7ff98
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1671028Reviewed-by: Mike Dougherty <michaeldo@chromium.org>
Commit-Queue: Kurt Horimoto <kkhorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#672660}

ios/chrome/browser/overlays/BUILD.gn

@@ -6,7 +6,9 @@ source_set("overlays") {
   public = [
     "public/overlay_dismissal_callback.h",
     "public/overlay_modality.h",
+    "public/overlay_presentation_context.h",
     "public/overlay_presenter.h",
+    "public/overlay_presenter_observer.h",
     "public/overlay_request.h",
     "public/overlay_request_queue.h",
     "public/overlay_response.h",

ios/chrome/browser/overlays/README.md

@@ -32,19 +32,20 @@ scheduling logic for that request's corresponding overlay UI.
 OverlayPresenter drives the presentation of the UI for OverlayRequests added to
 queues for WebStates in a Browser.
 
-#### OverlayPresenter::UIDelegate
+#### OverlayPresentationContext
 
-Clients must provide a UI delegate to a Browser's OverlayPresenter that handles
-the presentation of overlay UI for that presenter's modality and Browser.
+Clients must provide a presentation context to a Browser's OverlayPresenter that
+handles the presentation of overlay UI for that presenter's modality and
+Browser.
 
-#### OverlayPresenter::Observer
+#### OverlayPresenterObserver
 
 Objects that care about the presentation and dismissal of overlay UI by the
 presenter should add themselves as observers to the presenter.  This can be used
 to respond to update UI for UI presentation, for example to update the location
 bar text while a dialog is displayed.
 
-## Setting up OverlayPresenterr:
+## Setting up OverlayPresenter:
 
 Multiple OverlayPresenters may be active for a single Browser to manage overlay
 UI at different levels of modality (i.e. modal over WebState content area, modal

ios/chrome/browser/overlays/overlay_presenter_impl.h

@@ -8,6 +8,7 @@
 #include "base/memory/weak_ptr.h"
 #import "ios/chrome/browser/main/browser_observer.h"
 #import "ios/chrome/browser/overlays/overlay_request_queue_impl.h"
+#import "ios/chrome/browser/overlays/public/overlay_dismissal_callback.h"
 #import "ios/chrome/browser/overlays/public/overlay_modality.h"
 #import "ios/chrome/browser/overlays/public/overlay_presenter.h"
 #import "ios/chrome/browser/overlays/public/overlay_user_data.h"
@@ -45,9 +46,10 @@ class OverlayPresenterImpl : public BrowserObserver,
   };
 
   // OverlayPresenter:
-  void SetUIDelegate(UIDelegate* delegate) override;
-  void AddObserver(OverlayPresenter::Observer* observer) override;
-  void RemoveObserver(OverlayPresenter::Observer* observer) override;
+  void SetPresentationContext(
+      OverlayPresentationContext* presentation_context) override;
+  void AddObserver(OverlayPresenterObserver* observer) override;
+  void RemoveObserver(OverlayPresenterObserver* observer) override;
 
  private:
   // Private constructor used by the container.
@@ -75,11 +77,11 @@ class OverlayPresenterImpl : public BrowserObserver,
   // only be called when |presenting_| is false.
   void PresentOverlayForActiveRequest();
 
-  // Notifies this object that |ui_delegate| has finished dismissing the
-  // overlay UI corresponding with |request| in |queue| for |reason|.  This
-  // function is called when the OverlayDismissalCallback provided to the UI
-  // delegate is executed.
-  void OverlayWasDismissed(UIDelegate* ui_delegate,
+  // Notifies this object that the UI for |request| has finished being dismissed
+  // in |presentation_context| in for |reason|.  |queue| is |request|'s queue.
+  // This function is called when the OverlayDismissalCallback provided to
+  // |presentation_context| is executed.
+  void OverlayWasDismissed(OverlayPresentationContext* presentation_context,
                            OverlayRequest* request,
                            base::WeakPtr<OverlayRequestQueueImpl> queue,
                            OverlayDismissalReason reason);
@@ -127,8 +129,8 @@ class OverlayPresenterImpl : public BrowserObserver,
   OverlayModality modality_;
   WebStateList* web_state_list_ = nullptr;
   web::WebState* active_web_state_ = nullptr;
-  UIDelegate* ui_delegate_ = nullptr;
-  base::ObserverList<OverlayPresenter::Observer,
+  OverlayPresentationContext* presentation_context_ = nullptr;
+  base::ObserverList<OverlayPresenterObserver,
                      /* check_empty= */ true>
       observers_;
   base::WeakPtrFactory<OverlayPresenterImpl> weak_factory_;

ios/chrome/browser/overlays/overlay_presenter_impl.mm

@@ -6,6 +6,8 @@
 
 #include "base/logging.h"
 #import "ios/chrome/browser/main/browser.h"
+#import "ios/chrome/browser/overlays/public/overlay_presentation_context.h"
+#import "ios/chrome/browser/overlays/public/overlay_presenter_observer.h"
 #include "ios/chrome/browser/overlays/public/overlay_request.h"
 #import "ios/chrome/browser/web_state_list/web_state_list.h"
 
@@ -62,7 +64,7 @@ OverlayPresenterImpl::OverlayPresenterImpl(Browser* browser,
 OverlayPresenterImpl::~OverlayPresenterImpl() {
   // The presenter should be disconnected from WebStateList changes before
   // destruction.
-  DCHECK(!ui_delegate_);
+  DCHECK(!presentation_context_);
   DCHECK(!web_state_list_);
 
   for (auto& observer : observers_) {
@@ -74,29 +76,29 @@ OverlayPresenterImpl::~OverlayPresenterImpl() {
 
 #pragma mark OverlayPresenter
 
-void OverlayPresenterImpl::SetUIDelegate(UIDelegate* ui_delegate) {
-  // When the UI delegate is reset, the presenter will begin showing overlays in
-  // the new delegate's presentation context.  Cancel overlay state from the
-  // previous delegate since this Browser's overlays will no longer be presented
+void OverlayPresenterImpl::SetPresentationContext(
+    OverlayPresentationContext* presentation_context) {
+  // When the presentation context is reset, the presenter will begin showing
+  // overlays in the new presentation context.  Cancel overlay state from the
+  // previous context since this Browser's overlays will no longer be presented
   // there.
-  if (ui_delegate_)
+  if (presentation_context_)
     CancelAllOverlayUI();
 
-  ui_delegate_ = ui_delegate;
+  presentation_context_ = presentation_context;
 
   // Reset |presenting| since it was tracking the status for the previous
   // delegate's presentation context.
   presenting_ = false;
-  if (ui_delegate_)
+  if (presentation_context_)
     PresentOverlayForActiveRequest();
 }
 
-void OverlayPresenterImpl::AddObserver(OverlayPresenter::Observer* observer) {
+void OverlayPresenterImpl::AddObserver(OverlayPresenterObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void OverlayPresenterImpl::RemoveObserver(
-    OverlayPresenter::Observer* observer) {
+void OverlayPresenterImpl::RemoveObserver(OverlayPresenterObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ -124,7 +126,7 @@ void OverlayPresenterImpl::SetActiveWebState(
   detaching_active_web_state_ = false;
 
   // Early return if there's no UI delegate, since presentation cannot occur.
-  if (!ui_delegate_)
+  if (!presentation_context_)
     return;
 
   // If not already presenting, immediately show the next overlay.
@@ -143,7 +145,7 @@ void OverlayPresenterImpl::SetActiveWebState(
   } else {
     // For WebState activations, the overlay UI for the previously active
     // WebState should be hidden, as it may be shown again upon reactivating.
-    ui_delegate_->HideOverlayUI(this, previously_active_request);
+    presentation_context_->HideOverlayUI(this, previously_active_request);
   }
 }
 
@@ -177,7 +179,7 @@ void OverlayPresenterImpl::PresentOverlayForActiveRequest() {
   DCHECK(!presenting_);
 
   // Overlays cannot be shown without a UI delegate.
-  if (!ui_delegate_)
+  if (!presentation_context_)
     return;
 
   // No presentation is necessary if there is no active reqeust.
@@ -195,12 +197,13 @@ void OverlayPresenterImpl::PresentOverlayForActiveRequest() {
   // Present the overlay UI via the UI delegate.
   OverlayDismissalCallback dismissal_callback = base::BindOnce(
       &OverlayPresenterImpl::OverlayWasDismissed, weak_factory_.GetWeakPtr(),
-      ui_delegate_, request, GetActiveQueue()->GetWeakPtr());
-  ui_delegate_->ShowOverlayUI(this, request, std::move(dismissal_callback));
+      presentation_context_, request, GetActiveQueue()->GetWeakPtr());
+  presentation_context_->ShowOverlayUI(this, request,
+                                       std::move(dismissal_callback));
 }
 
 void OverlayPresenterImpl::OverlayWasDismissed(
-    UIDelegate* ui_delegate,
+    OverlayPresentationContext* presentation_context,
     OverlayRequest* request,
     base::WeakPtr<OverlayRequestQueueImpl> queue,
     OverlayDismissalReason reason) {
@@ -208,7 +211,7 @@ void OverlayPresenterImpl::OverlayWasDismissed(
   // be cancelled and dismissed.  The presenter is now using the new UI
   // delegate's presentation context, so this dismissal should not trigger
   // presentation logic.
-  if (ui_delegate_ != ui_delegate)
+  if (presentation_context_ != presentation_context)
     return;
 
   // Pop the request for overlays dismissed by the user.  The check against the
@@ -239,9 +242,9 @@ void OverlayPresenterImpl::OverlayWasDismissed(
 #pragma mark Cancellation helpers
 
 void OverlayPresenterImpl::CancelOverlayUIForRequest(OverlayRequest* request) {
-  if (!ui_delegate_ || !request)
+  if (!presentation_context_ || !request)
     return;
-  ui_delegate_->CancelOverlayUI(this, request);
+  presentation_context_->CancelOverlayUI(this, request);
 }
 
 void OverlayPresenterImpl::CancelAllOverlayUI() {
@@ -255,7 +258,7 @@ void OverlayPresenterImpl::CancelAllOverlayUI() {
 #pragma mark BrowserObserver
 
 void OverlayPresenterImpl::BrowserDestroyed(Browser* browser) {
-  SetUIDelegate(nullptr);
+  SetPresentationContext(nullptr);
   SetActiveWebState(nullptr, CHANGE_REASON_NONE);
 
   for (int i = 0; i < web_state_list_->count(); ++i) {

ios/chrome/browser/overlays/public/overlay_presentation_context.h

+// Copyright 2019 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.
+
+#ifndef IOS_CHROME_BROWSER_OVERLAYS_PUBLIC_OVERLAY_PRESENTATION_CONTEXT_H_
+#define IOS_CHROME_BROWSER_OVERLAYS_PUBLIC_OVERLAY_PRESENTATION_CONTEXT_H_
+
+#include "ios/chrome/browser/overlays/public/overlay_dismissal_callback.h"
+
+class OverlayPresenter;
+class OverlayRequest;
+
+// Object that handles presenting the overlay UI for OverlayPresenter.
+class OverlayPresentationContext {
+ public:
+  OverlayPresentationContext() = default;
+  virtual ~OverlayPresentationContext() = default;
+
+  // Called by |presenter| to show the overlay UI for |request|.
+  // |dismissal_callback| must be stored and called whenever the UI is finished
+  // being dismissed for user interaction, hiding, or cancellation.
+  virtual void ShowOverlayUI(OverlayPresenter* presenter,
+                             OverlayRequest* request,
+                             OverlayDismissalCallback dismissal_callback) = 0;
+
+  // Called by |presenter| to hide the overlay UI for |request|.  Hidden
+  // overlays may be shown again, so they should be kept in memory or
+  // serialized so that the state can be restored if shown again.  When hiding
+  // an overlay, the presented UI must be dismissed, and the overlay's
+  // dismissal callback must must be executed upon the dismissal's completion.
+  virtual void HideOverlayUI(OverlayPresenter* presenter,
+                             OverlayRequest* request) = 0;
+
+  // Called by |presenter| to cancel the overlay UI for |request|.  If the UI
+  // is presented, it should be dismissed and the dismissal callback should be
+  // executed upon the dismissal's completion.  Otherwise, any state
+  // corresponding to any hidden overlays should be cleaned up.
+  virtual void CancelOverlayUI(OverlayPresenter* presenter,
+                               OverlayRequest* request) = 0;
+};
+
+#endif  // IOS_CHROME_BROWSER_OVERLAYS_PUBLIC_OVERLAY_PRESENTATION_CONTEXT_H_

ios/chrome/browser/overlays/public/overlay_presenter.h

@@ -7,12 +7,11 @@
 
 #include <memory>
 
-#include "base/observer_list_types.h"
-#include "ios/chrome/browser/overlays/public/overlay_dismissal_callback.h"
 #include "ios/chrome/browser/overlays/public/overlay_modality.h"
 
 class Browser;
-class OverlayRequest;
+class OverlayPresenterObserver;
+class OverlayPresentationContext;
 
 // OverlayPresenter handles the presentation of overlay UI for OverlayRequests
 // added to the OverlayRequestQueues for WebStates in a Browser.
@@ -25,62 +24,15 @@ class OverlayPresenter {
   static OverlayPresenter* FromBrowser(Browser* browser,
                                        OverlayModality modality);
 
-  // Delegate that handles presenting the overlay UI for OverlayPresenter
-  class UIDelegate : public base::CheckedObserver {
-   public:
-    UIDelegate() = default;
-
-    // Called by |presenter| to show the overlay UI for |request|.
-    // |dismissal_callback| must be stored by the delegate and called whenever
-    // the UI is finished being dismissed for user interaction, hiding, or
-    // cancellation.
-    virtual void ShowOverlayUI(OverlayPresenter* presenter,
-                               OverlayRequest* request,
-                               OverlayDismissalCallback dismissal_callback) = 0;
-
-    // Called by |presenter| to hide the overlay UI for |request|.  Hidden
-    // overlays may be shown again, so they should be kept in memory or
-    // serialized so that the state can be restored if shown again.  When hiding
-    // an overlay, the presented UI must be dismissed, and the overlay's
-    // dismissal callback must must be executed upon the dismissal's completion.
-    virtual void HideOverlayUI(OverlayPresenter* presenter,
-                               OverlayRequest* request) = 0;
-
-    // Called by |presenter| to cancel the overlay UI for |request|.  If the UI
-    // is presented, it should be dismissed and the dismissal callback should be
-    // executed upon the dismissal's completion.  Otherwise, any state
-    // corresponding to any hidden overlays should be cleaned up.
-    virtual void CancelOverlayUI(OverlayPresenter* presenter,
-                                 OverlayRequest* request) = 0;
-  };
-
-  // Sets the UI delegate for the presenter.  Upon being set, the presenter will
-  // attempt to begin presenting overlay UI for the active WebState in its
-  // Browser.
-  virtual void SetUIDelegate(UIDelegate* delegate) = 0;
-
-  // Observer interface for objects interested in overlay presentation events
-  // triggered by OverlayPresenter.
-  class Observer : public base::CheckedObserver {
-   public:
-    Observer() = default;
-
-    // Called when |presenter| is about to show the overlay UI for |request|.
-    virtual void WillShowOverlay(OverlayPresenter* presenter,
-                                 OverlayRequest* request) {}
-
-    // Called when |presenter| is finished dismissing the overlay UI for
-    // |request|.
-    virtual void DidHideOverlay(OverlayPresenter* presenter,
-                                OverlayRequest* request) {}
-
-    // Called when |presenter| is destroyed.
-    virtual void OverlayPresenterDestroyed(OverlayPresenter* presenter) {}
-  };
+  // Sets the presentation context in which to show overlay UI.  Upon being set,
+  // the presenter will attempt to begin presenting overlay UI for the active
+  // WebState in its Browser.
+  virtual void SetPresentationContext(
+      OverlayPresentationContext* presentation_context) = 0;
 
   // Adds and removes observers.
-  virtual void AddObserver(Observer* observer) = 0;
-  virtual void RemoveObserver(Observer* observer) = 0;
+  virtual void AddObserver(OverlayPresenterObserver* observer) = 0;
+  virtual void RemoveObserver(OverlayPresenterObserver* observer) = 0;
 };
 
 #endif  // IOS_CHROME_BROWSER_OVERLAYS_PUBLIC_OVERLAY_PRESENTER_H_

ios/chrome/browser/overlays/public/overlay_presenter_observer.h

+// Copyright 2019 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.
+
+#ifndef IOS_CHROME_BROWSER_OVERLAYS_PUBLIC_OVERLAY_PRESENTER_OBSERVER_H_
+#define IOS_CHROME_BROWSER_OVERLAYS_PUBLIC_OVERLAY_PRESENTER_OBSERVER_H_
+
+#include "base/observer_list_types.h"
+
+class OverlayPresenter;
+class OverlayRequest;
+
+// Observer interface for objects interested in overlay presentation events
+// triggered by OverlayPresenter.
+class OverlayPresenterObserver : public base::CheckedObserver {
+ public:
+  OverlayPresenterObserver() = default;
+
+  // Called when |presenter| is about to show the overlay UI for |request|.
+  virtual void WillShowOverlay(OverlayPresenter* presenter,
+                               OverlayRequest* request) {}
+
+  // Called when |presenter| is finished dismissing its overlay UI.
+  virtual void DidHideOverlay(OverlayPresenter* presenter,
+                              OverlayRequest* request) {}
+
+  // Called when |presenter| is destroyed.
+  virtual void OverlayPresenterDestroyed(OverlayPresenter* presenter) {}
+};
+
+#endif  // IOS_CHROME_BROWSER_OVERLAYS_PUBLIC_OVERLAY_PRESENTER_OBSERVER_H_

ios/chrome/browser/overlays/test/BUILD.gn

@@ -5,8 +5,8 @@
 source_set("test") {
   testonly = true
   sources = [
-    "fake_overlay_presenter_ui_delegate.cc",
-    "fake_overlay_presenter_ui_delegate.h",
+    "fake_overlay_presentation_context.cc",
+    "fake_overlay_presentation_context.h",
     "fake_overlay_user_data.cc",
     "fake_overlay_user_data.h",
   ]

ios/chrome/browser/overlays/test/fake_overlay_presenter_ui_delegate.cc → ios/chrome/browser/overlays/test/fake_overlay_presentation_context.cc

@@ -2,21 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ios/chrome/browser/overlays/test/fake_overlay_presenter_ui_delegate.h"
+#include "ios/chrome/browser/overlays/test/fake_overlay_presentation_context.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "ios/chrome/browser/overlays/public/overlay_request_queue.h"
 
-FakeOverlayPresenterUIDelegate::FakeOverlayPresenterUIDelegate() = default;
-FakeOverlayPresenterUIDelegate::~FakeOverlayPresenterUIDelegate() = default;
+FakeOverlayPresentationContext::FakeOverlayPresentationContext() = default;
+FakeOverlayPresentationContext::~FakeOverlayPresentationContext() = default;
 
-FakeOverlayPresenterUIDelegate::PresentationState
-FakeOverlayPresenterUIDelegate::GetPresentationState(OverlayRequest* request) {
+FakeOverlayPresentationContext::PresentationState
+FakeOverlayPresentationContext::GetPresentationState(OverlayRequest* request) {
   return presentation_states_[request];
 }
 
-void FakeOverlayPresenterUIDelegate::SimulateDismissalForRequest(
+void FakeOverlayPresentationContext::SimulateDismissalForRequest(
     OverlayRequest* request,
     OverlayDismissalReason reason) {
   DCHECK_EQ(PresentationState::kPresented, presentation_states_[request]);
@@ -34,7 +34,7 @@ void FakeOverlayPresenterUIDelegate::SimulateDismissalForRequest(
   std::move(overlay_callbacks_[request]).Run(reason);
 }
 
-void FakeOverlayPresenterUIDelegate::ShowOverlayUI(
+void FakeOverlayPresentationContext::ShowOverlayUI(
     OverlayPresenter* presenter,
     OverlayRequest* request,
     OverlayDismissalCallback dismissal_callback) {
@@ -42,12 +42,12 @@ void FakeOverlayPresenterUIDelegate::ShowOverlayUI(
   overlay_callbacks_[request] = std::move(dismissal_callback);
 }
 
-void FakeOverlayPresenterUIDelegate::HideOverlayUI(OverlayPresenter* presenter,
+void FakeOverlayPresentationContext::HideOverlayUI(OverlayPresenter* presenter,
                                                    OverlayRequest* request) {
   SimulateDismissalForRequest(request, OverlayDismissalReason::kHiding);
 }
 
-void FakeOverlayPresenterUIDelegate::CancelOverlayUI(
+void FakeOverlayPresentationContext::CancelOverlayUI(
     OverlayPresenter* presenter,
     OverlayRequest* request) {
   PresentationState& state = presentation_states_[request];

ios/chrome/browser/overlays/test/fake_overlay_presenter_ui_delegate.h → ios/chrome/browser/overlays/test/fake_overlay_presentation_context.h

@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef IOS_CHROME_BROWSER_OVERLAYS_TEST_FAKE_OVERLAY_PRESENTER_UI_DELEGATE_H_
-#define IOS_CHROME_BROWSER_OVERLAYS_TEST_FAKE_OVERLAY_PRESENTER_UI_DELEGATE_H_
+#ifndef IOS_CHROME_BROWSER_OVERLAYS_TEST_FAKE_OVERLAY_PRESENTATION_CONTEXT_H_
+#define IOS_CHROME_BROWSER_OVERLAYS_TEST_FAKE_OVERLAY_PRESENTATION_CONTEXT_H_
 
 #include <map>
 
-#include "ios/chrome/browser/overlays/public/overlay_presenter.h"
+#include "ios/chrome/browser/overlays/public/overlay_presentation_context.h"
 #include "ios/chrome/browser/overlays/public/overlay_request.h"
 
 // Fake implementation of OverlayUIDelegate used for testing.
-class FakeOverlayPresenterUIDelegate : public OverlayPresenter::UIDelegate {
+class FakeOverlayPresentationContext : public OverlayPresentationContext {
  public:
-  FakeOverlayPresenterUIDelegate();
-  ~FakeOverlayPresenterUIDelegate() override;
+  FakeOverlayPresentationContext();
+  ~FakeOverlayPresentationContext() override;
 
   // Enum describing the state of the overlay UI.
   enum class PresentationState {
@@ -52,4 +52,4 @@ class FakeOverlayPresenterUIDelegate : public OverlayPresenter::UIDelegate {
   std::map<OverlayRequest*, OverlayDismissalCallback> overlay_callbacks_;
 };
 
-#endif  // IOS_CHROME_BROWSER_OVERLAYS_TEST_FAKE_OVERLAY_PRESENTER_UI_DELEGATE_H_
+#endif  // IOS_CHROME_BROWSER_OVERLAYS_TEST_FAKE_OVERLAY_PRESENTATION_CONTEXT_H_

ios/chrome/browser/ui/overlays/BUILD.gn

@@ -11,8 +11,8 @@ source_set("overlays") {
     "overlay_container_coordinator.mm",
     "overlay_coordinator_factory+initialization.h",
     "overlay_coordinator_factory.mm",
-    "overlay_presenter_ui_delegate_impl.h",
-    "overlay_presenter_ui_delegate_impl.mm",
+    "overlay_presentation_context_impl.h",
+    "overlay_presentation_context_impl.mm",
     "overlay_request_ui_state.h",
     "overlay_request_ui_state.mm",
   ]

ios/chrome/browser/ui/overlays/overlay_container_coordinator.mm

@@ -10,7 +10,7 @@
 #include "base/logging.h"
 #import "ios/chrome/browser/main/browser.h"
 #import "ios/chrome/browser/ui/overlays/overlay_container_view_controller.h"
-#import "ios/chrome/browser/ui/overlays/overlay_presenter_ui_delegate_impl.h"
+#import "ios/chrome/browser/ui/overlays/overlay_presentation_context_impl.h"
 #import "ios/chrome/common/ui_util/constraints_ui_util.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
@@ -22,7 +22,7 @@
 // Whether the coordinator is started.
 @property(nonatomic, assign, getter=isStarted) BOOL started;
 // The UI delegate that is used to drive presentation for this container.
-@property(nonatomic, readonly) OverlayPresenterUIDelegateImpl* UIDelegate;
+@property(nonatomic, readonly) OverlayPresentationContextImpl* UIDelegate;
 @end
 
 @implementation OverlayContainerCoordinator
@@ -32,11 +32,11 @@
                                   modality:(OverlayModality)modality {
   if (self = [super initWithBaseViewController:viewController
                                        browser:browser]) {
-    OverlayPresenterUIDelegateImpl::Container::CreateForUserData(browser,
+    OverlayPresentationContextImpl::Container::CreateForUserData(browser,
                                                                  browser);
     _UIDelegate =
-        OverlayPresenterUIDelegateImpl::Container::FromUserData(browser)
-            ->UIDelegateForModality(modality);
+        OverlayPresentationContextImpl::Container::FromUserData(browser)
+            ->PresentationContextForModality(modality);
     DCHECK(_UIDelegate);
   }
   return self;

ios/chrome/browser/ui/overlays/overlay_presenter_ui_delegate_impl.h → ios/chrome/browser/ui/overlays/overlay_presentation_context_impl.h

@@ -2,12 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_PRESENTER_UI_DELEGATE_IMPL_H_
-#define IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_PRESENTER_UI_DELEGATE_IMPL_H_
+#ifndef IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_PRESENTATION_CONTEXT_IMPL_H_
+#define IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_PRESENTATION_CONTEXT_IMPL_H_
 
 #include "base/memory/weak_ptr.h"
 #import "ios/chrome/browser/main/browser_observer.h"
-#import "ios/chrome/browser/overlays/public/overlay_presenter.h"
+#include "ios/chrome/browser/overlays/public/overlay_modality.h"
+#import "ios/chrome/browser/overlays/public/overlay_presentation_context.h"
 #import "ios/chrome/browser/overlays/public/overlay_user_data.h"
 #import "ios/chrome/browser/ui/overlays/overlay_request_coordinator.h"
 #import "ios/chrome/browser/ui/overlays/overlay_request_ui_state.h"
@@ -16,27 +17,27 @@
 @class OverlayRequestCoordinatorFactory;
 @class OverlayContainerCoordinator;
 
-// Implementation of OverlayPresenter::UIDelegate.  An instance of this class
+// Implementation of OverlayPresentationContext.  An instance of this class
 // exists for every OverlayModality for each Browser.  This delegate is scoped
 // to the Browser because it needs to store state even when a Browser's UI is
 // not on screen.  When a Browser's UI is shown, the OverlayContainerCoordinator
 // for each of its OverlayModalities will supply itself to the delegate, which
 // will then present the UI using the container coordinator's presentation
 // context.
-class OverlayPresenterUIDelegateImpl : public OverlayPresenter::UIDelegate {
+class OverlayPresentationContextImpl : public OverlayPresentationContext {
  public:
-  ~OverlayPresenterUIDelegateImpl() override;
+  ~OverlayPresentationContextImpl() override;
 
   // Container that stores the UI delegate for each modality.  Usage example:
   //
-  // OverlayPresenterUIDelegateImpl::Container::FromUserData(browser)->
-  //     UIDelegateForModality(OverlayModality::kWebContentArea);
+  // OverlayPresentationContextImpl::Container::FromUserData(browser)->
+  //     PresentationContextForModality(OverlayModality::kWebContentArea);
   class Container : public OverlayUserData<Container> {
    public:
     ~Container() override;
 
-    // Returns the OverlayPresenterUIDelegateImpl for |modality|.
-    OverlayPresenterUIDelegateImpl* UIDelegateForModality(
+    // Returns the OverlayPresentationContextImpl for |modality|.
+    OverlayPresentationContextImpl* PresentationContextForModality(
         OverlayModality modality);
 
    private:
@@ -44,7 +45,7 @@ class OverlayPresenterUIDelegateImpl : public OverlayPresenter::UIDelegate {
     explicit Container(Browser* browser);
 
     Browser* browser_ = nullptr;
-    std::map<OverlayModality, std::unique_ptr<OverlayPresenterUIDelegateImpl>>
+    std::map<OverlayModality, std::unique_ptr<OverlayPresentationContextImpl>>
         ui_delegates_;
   };
 
@@ -54,7 +55,7 @@ class OverlayPresenterUIDelegateImpl : public OverlayPresenter::UIDelegate {
   OverlayContainerCoordinator* coordinator() const { return coordinator_; }
   void SetCoordinator(OverlayContainerCoordinator* coordinator);
 
-  // OverlayPresenter::UIDelegate:
+  // OverlayPresentationContext:
   void ShowOverlayUI(OverlayPresenter* presenter,
                      OverlayRequest* request,
                      OverlayDismissalCallback dismissal_callback) override;
@@ -64,7 +65,7 @@ class OverlayPresenterUIDelegateImpl : public OverlayPresenter::UIDelegate {
                        OverlayRequest* request) override;
 
  private:
-  OverlayPresenterUIDelegateImpl(Browser* browser, OverlayModality modality);
+  OverlayPresentationContextImpl(Browser* browser, OverlayModality modality);
 
   // Setter for |request_|.  Setting to a new value will attempt to
   // present the UI for |request|.
@@ -102,14 +103,14 @@ class OverlayPresenterUIDelegateImpl : public OverlayPresenter::UIDelegate {
   // Helper object that listens for UI dismissal events.
   class OverlayDismissalHelper : public OverlayUIDismissalDelegate {
    public:
-    OverlayDismissalHelper(OverlayPresenterUIDelegateImpl* ui_delegate);
+    OverlayDismissalHelper(OverlayPresentationContextImpl* ui_delegate);
     ~OverlayDismissalHelper() override;
 
     // OverlayUIDismissalDelegate:
     void OverlayUIDidFinishDismissal(OverlayRequest* request) override;
 
    private:
-    OverlayPresenterUIDelegateImpl* ui_delegate_ = nullptr;
+    OverlayPresentationContextImpl* ui_delegate_ = nullptr;
   };
 
   // The presenter whose UI is being handled by this delegate.
@@ -131,7 +132,7 @@ class OverlayPresenterUIDelegateImpl : public OverlayPresenter::UIDelegate {
   // Map storing the UI state for each OverlayRequest.
   std::map<OverlayRequest*, std::unique_ptr<OverlayRequestUIState>> states_;
   // Weak pointer factory.
-  base::WeakPtrFactory<OverlayPresenterUIDelegateImpl> weak_factory_;
+  base::WeakPtrFactory<OverlayPresentationContextImpl> weak_factory_;
 };
 
-#endif  // IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_PRESENTER_UI_DELEGATE_IMPL_H_
+#endif  // IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_PRESENTATION_CONTEXT_IMPL_H_

ios/chrome/browser/ui/overlays/overlay_presenter_ui_delegate_impl.mm → ios/chrome/browser/ui/overlays/overlay_presentation_context_impl.mm

@@ -2,11 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#import "ios/chrome/browser/ui/overlays/overlay_presenter_ui_delegate_impl.h"
+#import "ios/chrome/browser/ui/overlays/overlay_presentation_context_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #import "ios/chrome/browser/main/browser.h"
+#import "ios/chrome/browser/overlays/public/overlay_presenter.h"
 #import "ios/chrome/browser/ui/overlays/overlay_container_coordinator.h"
 #import "ios/chrome/browser/ui/overlays/overlay_coordinator_factory.h"
 
@@ -14,31 +15,31 @@
 #error "This file requires ARC support."
 #endif
 
-#pragma mark - OverlayPresenterUIDelegateImpl::Container
+#pragma mark - OverlayPresentationContextImpl::Container
 
-OVERLAY_USER_DATA_SETUP_IMPL(OverlayPresenterUIDelegateImpl::Container);
+OVERLAY_USER_DATA_SETUP_IMPL(OverlayPresentationContextImpl::Container);
 
-OverlayPresenterUIDelegateImpl::Container::Container(Browser* browser)
+OverlayPresentationContextImpl::Container::Container(Browser* browser)
     : browser_(browser) {
   DCHECK(browser_);
 }
 
-OverlayPresenterUIDelegateImpl::Container::~Container() = default;
+OverlayPresentationContextImpl::Container::~Container() = default;
 
-OverlayPresenterUIDelegateImpl*
-OverlayPresenterUIDelegateImpl::Container::UIDelegateForModality(
+OverlayPresentationContextImpl*
+OverlayPresentationContextImpl::Container::PresentationContextForModality(
     OverlayModality modality) {
   auto& ui_delegate = ui_delegates_[modality];
   if (!ui_delegate) {
     ui_delegate = base::WrapUnique(
-        new OverlayPresenterUIDelegateImpl(browser_, modality));
+        new OverlayPresentationContextImpl(browser_, modality));
   }
   return ui_delegate.get();
 }
 
-#pragma mark - OverlayPresenterUIDelegateImpl
+#pragma mark - OverlayPresentationContextImpl
 
-OverlayPresenterUIDelegateImpl::OverlayPresenterUIDelegateImpl(
+OverlayPresentationContextImpl::OverlayPresentationContextImpl(
     Browser* browser,
     OverlayModality modality)
     : presenter_(OverlayPresenter::FromBrowser(browser, modality)),
@@ -50,14 +51,14 @@ OverlayPresenterUIDelegateImpl::OverlayPresenterUIDelegateImpl(
       weak_factory_(this) {
   DCHECK(presenter_);
   DCHECK(coordinator_factory_);
-  presenter_->SetUIDelegate(this);
+  presenter_->SetPresentationContext(this);
 }
 
-OverlayPresenterUIDelegateImpl::~OverlayPresenterUIDelegateImpl() = default;
+OverlayPresentationContextImpl::~OverlayPresentationContextImpl() = default;
 
 #pragma mark Public
 
-void OverlayPresenterUIDelegateImpl::SetCoordinator(
+void OverlayPresentationContextImpl::SetCoordinator(
     OverlayContainerCoordinator* coordinator) {
   if (coordinator_ == coordinator)
     return;
@@ -72,9 +73,9 @@ void OverlayPresenterUIDelegateImpl::SetCoordinator(
   ShowUIForPresentedRequest();
 }
 
-#pragma mark OverlayPresenter::UIDelegate
+#pragma mark OverlayPresentationContext
 
-void OverlayPresenterUIDelegateImpl::ShowOverlayUI(
+void OverlayPresentationContextImpl::ShowOverlayUI(
     OverlayPresenter* presenter,
     OverlayRequest* request,
     OverlayDismissalCallback dismissal_callback) {
@@ -88,7 +89,7 @@ void OverlayPresenterUIDelegateImpl::ShowOverlayUI(
   SetRequest(request);
 }
 
-void OverlayPresenterUIDelegateImpl::HideOverlayUI(OverlayPresenter* presenter,
+void OverlayPresentationContextImpl::HideOverlayUI(OverlayPresenter* presenter,
                                                    OverlayRequest* request) {
   DCHECK_EQ(presenter_, presenter);
   DCHECK_EQ(request_, request);
@@ -107,7 +108,7 @@ void OverlayPresenterUIDelegateImpl::HideOverlayUI(OverlayPresenter* presenter,
   }
 }
 
-void OverlayPresenterUIDelegateImpl::CancelOverlayUI(
+void OverlayPresentationContextImpl::CancelOverlayUI(
     OverlayPresenter* presenter,
     OverlayRequest* request) {
   DCHECK_EQ(presenter_, presenter);
@@ -136,7 +137,7 @@ void OverlayPresenterUIDelegateImpl::CancelOverlayUI(
 
 #pragma mark Accesors
 
-void OverlayPresenterUIDelegateImpl::SetRequest(OverlayRequest* request) {
+void OverlayPresentationContextImpl::SetRequest(OverlayRequest* request) {
   if (request_ == request)
     return;
   if (request_) {
@@ -164,14 +165,14 @@ void OverlayPresenterUIDelegateImpl::SetRequest(OverlayRequest* request) {
   ShowUIForPresentedRequest();
 }
 
-OverlayRequestUIState* OverlayPresenterUIDelegateImpl::GetRequestUIState(
+OverlayRequestUIState* OverlayPresentationContextImpl::GetRequestUIState(
     OverlayRequest* request) {
   return request ? states_[request].get() : nullptr;
 }
 
 #pragma mark Presentation and Dismissal helpers
 
-void OverlayPresenterUIDelegateImpl::ShowUIForPresentedRequest() {
+void OverlayPresentationContextImpl::ShowUIForPresentedRequest() {
   OverlayRequestUIState* state = GetRequestUIState(request_);
   if (!state || !coordinator_)
     return;
@@ -192,7 +193,7 @@ void OverlayPresenterUIDelegateImpl::ShowUIForPresentedRequest() {
   state->OverlayUIWasPresented();
 }
 
-void OverlayPresenterUIDelegateImpl::DismissPresentedUI(
+void OverlayPresentationContextImpl::DismissPresentedUI(
     OverlayDismissalReason reason) {
   OverlayRequestUIState* state = GetRequestUIState(request_);
   DCHECK(state);
@@ -204,7 +205,7 @@ void OverlayPresenterUIDelegateImpl::DismissPresentedUI(
       stopAnimated:reason == OverlayDismissalReason::kUserInteraction];
 }
 
-void OverlayPresenterUIDelegateImpl::OverlayUIWasDismissed() {
+void OverlayPresentationContextImpl::OverlayUIWasDismissed() {
   DCHECK(request_);
   // Overlays are dismissed without animation when the container coordinator is
   // reset, but the state should not be notified of these dismissals since the
@@ -215,7 +216,7 @@ void OverlayPresenterUIDelegateImpl::OverlayUIWasDismissed() {
   NotifyStateOfDismissal();
 }
 
-void OverlayPresenterUIDelegateImpl::NotifyStateOfDismissal() {
+void OverlayPresentationContextImpl::NotifyStateOfDismissal() {
   DCHECK(request_);
   DCHECK(GetRequestUIState(request_)->has_callback());
   // If there is another request in the active WebState's OverlayRequestQueue,
@@ -231,7 +232,7 @@ void OverlayPresenterUIDelegateImpl::NotifyStateOfDismissal() {
 
 #pragma mark BrowserShutdownHelper
 
-OverlayPresenterUIDelegateImpl::BrowserShutdownHelper::BrowserShutdownHelper(
+OverlayPresentationContextImpl::BrowserShutdownHelper::BrowserShutdownHelper(
     Browser* browser,
     OverlayPresenter* presenter)
     : presenter_(presenter) {
@@ -239,27 +240,27 @@ OverlayPresenterUIDelegateImpl::BrowserShutdownHelper::BrowserShutdownHelper(
   browser->AddObserver(this);
 }
 
-OverlayPresenterUIDelegateImpl::BrowserShutdownHelper::
+OverlayPresentationContextImpl::BrowserShutdownHelper::
     ~BrowserShutdownHelper() = default;
 
-void OverlayPresenterUIDelegateImpl::BrowserShutdownHelper::BrowserDestroyed(
+void OverlayPresentationContextImpl::BrowserShutdownHelper::BrowserDestroyed(
     Browser* browser) {
-  presenter_->SetUIDelegate(nullptr);
+  presenter_->SetPresentationContext(nullptr);
   browser->RemoveObserver(this);
 }
 
 #pragma mark OverlayDismissalHelper
 
-OverlayPresenterUIDelegateImpl::OverlayDismissalHelper::OverlayDismissalHelper(
-    OverlayPresenterUIDelegateImpl* ui_delegate)
+OverlayPresentationContextImpl::OverlayDismissalHelper::OverlayDismissalHelper(
+    OverlayPresentationContextImpl* ui_delegate)
     : ui_delegate_(ui_delegate) {
   DCHECK(ui_delegate_);
 }
 
-OverlayPresenterUIDelegateImpl::OverlayDismissalHelper::
+OverlayPresentationContextImpl::OverlayDismissalHelper::
     ~OverlayDismissalHelper() = default;
 
-void OverlayPresenterUIDelegateImpl::OverlayDismissalHelper::
+void OverlayPresentationContextImpl::OverlayDismissalHelper::
     OverlayUIDidFinishDismissal(OverlayRequest* request) {
   DCHECK(request);
   DCHECK_EQ(ui_delegate_->request_, request);