Add public API for handling Javascript alerts and prompt.

ios/web/web_state/web_state_impl_unittest.mm

 // Copyright 2014 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 "ios/web/web_state/web_state_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/ios/wait_util.h"
 #include "base/values.h"
+#import "ios/web/public/java_script_dialog_presenter.h"
 #include "ios/web/public/load_committed_details.h"
 #include "ios/web/public/test/test_browser_state.h"
 #include "ios/web/public/test/web_test.h"
+#include "ios/web/public/web_state/context_menu_params.h"
 #include "ios/web/public/web_state/global_web_state_observer.h"
 #include "ios/web/public/web_state/web_state_delegate.h"
 #include "ios/web/public/web_state/web_state_observer.h"
 #include "ios/web/public/web_state/web_state_policy_decider.h"
 #include "ios/web/web_state/global_web_state_event_tracker.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 78 matching lines @@
   bool did_start_loading_called_;
   bool did_stop_loading_called_;
   bool page_loaded_called_with_success_;
   bool web_state_destroyed_called_;
 };
 
 // Test delegate to check that the WebStateDelegate methods are called as
 // expected.
 class TestWebStateDelegate : public WebStateDelegate {
  public:
-  TestWebStateDelegate() : load_progress_changed_called_(false) {}
+  TestWebStateDelegate()
+      : load_progress_changed_called_(false),
+        handle_context_menu_called_(false),
+        get_java_script_dialog_presenter_called_(false) {}
 
-  // Methods returning true if the corresponding WebStateObserver method has
-  // been called.
+  // True if the WebStateDelegate LoadProgressChanged method has been called.
   bool load_progress_changed_called() const {
     return load_progress_changed_called_;
   }
 
+  // True if the WebStateDelegate HandleContextMenu method has been called.
+  bool handle_context_menu_called() const {
+    return handle_context_menu_called_;
+  }
+
+  // True if the WebStateDelegate GetJavaScriptDialogPresenter method has been
+  // called.
+  bool get_java_script_dialog_presenter_called() const {
+    return get_java_script_dialog_presenter_called_;
+  }
+
+  void SetJavaScriptDialogPresenter(JavaScriptDialogPresenter* presenter) {
+    presenter_ = presenter;
+  }
+
  private:
-  // WebStateObserver implementation:
+  // WebStateDelegate implementation:
   void LoadProgressChanged(WebState* source, double progress) override {
     load_progress_changed_called_ = true;
   }
 
+  bool HandleContextMenu(WebState* source,
+                         const ContextMenuParams& params) override {
+    handle_context_menu_called_ = true;
+    return NO;
+  }
+
+  JavaScriptDialogPresenter* GetJavaScriptDialogPresenter(
+      WebState* source) override {
+    get_java_script_dialog_presenter_called_ = true;
+    return presenter_;
+  }
+
   bool load_progress_changed_called_;
+  bool handle_context_menu_called_;
+  bool get_java_script_dialog_presenter_called_;
+  JavaScriptDialogPresenter* presenter_;
+};
+
+// Test presenter to check that the JavaScriptDialogPresenter methods are called
+// as expected.
+class TestJavaScriptDialogPresenter : public JavaScriptDialogPresenter {
+ public:
+  TestJavaScriptDialogPresenter()
+      : cancel_active_and_pending_dialogs_called_(false),
+        run_java_script_dialog_called_(false) {}
+
+  // True if the JavaScriptDialogPresenter CancelActiveAndPendingDialogs method
+  // has been called.
+  bool cancel_active_and_pending_dialogs_called() const {
+    return cancel_active_and_pending_dialogs_called_;
+  }
+
+  // True if the JavaScriptDialogPresenter RunJavaScriptDialog method has been
+  // called.
+  bool run_java_script_dialog_called() const {
+    return run_java_script_dialog_called_;
+  }
+
+ private:
+  // JavaScriptDialogPresenter implementation:
+  void RunJavaScriptDialog(WebState* web_state,
+                           const GURL& origin_url,
+                           JavaScriptDialogType java_script_dialog_type,
+                           NSString* message_text,
+                           NSString* default_prompt_text,
+                           const DialogClosedCallback& callback) override {
+    run_java_script_dialog_called_ = true;
+    callback.Run(false, nil);
+  }
+
+  void CancelActiveAndPendingDialogs(WebState* web_state) override {
+    cancel_active_and_pending_dialogs_called_ = true;
+  }
+
+  bool cancel_active_and_pending_dialogs_called_;
+  bool run_java_script_dialog_called_;
 };
 
 // Test observer to check that the WebStateObserver methods are called as
 // expected.
 class TestWebStateObserver : public WebStateObserver {
  public:
   TestWebStateObserver(WebState* web_state)
       : WebStateObserver(web_state),
         provisional_navigation_started_called_(false),
         navigation_items_pruned_called_(false),
@@ skipping 264 matching lines @@
 
 // Tests that WebStateDelegate methods appropriately called.
 TEST_F(WebStateTest, DelegateTest) {
   TestWebStateDelegate delegate;
   web_state_->SetDelegate(&delegate);
 
   // Test that LoadProgressChanged() is called.
   EXPECT_FALSE(delegate.load_progress_changed_called());
   web_state_->SendChangeLoadProgress(0.0);
   EXPECT_TRUE(delegate.load_progress_changed_called());
+
+  // Test that HandleContextMenu() is called.
+  EXPECT_FALSE(delegate.handle_context_menu_called());
+  web::ContextMenuParams context_menu_params;
+  web_state_->HandleContextMenu(context_menu_params);
+  EXPECT_TRUE(delegate.handle_context_menu_called());
+
+  // Test that GetJavaScriptDialogPresenter() is called.
+  TestJavaScriptDialogPresenter presenter;
+  delegate.SetJavaScriptDialogPresenter(&presenter);
+
+  EXPECT_FALSE(delegate.get_java_script_dialog_presenter_called());
+  EXPECT_FALSE(presenter.run_java_script_dialog_called());
+  EXPECT_FALSE(presenter.cancel_active_and_pending_dialogs_called());
+
+  __block bool callback_called = false;
+  web_state_->RunJavaScriptDialog(GURL(), JAVASCRIPT_DIALOG_TYPE_ALERT, @"",
+                                  nil, base::BindBlock(^(bool, NSString*) {
+                                    callback_called = true;
+                                  }));
+
+  EXPECT_TRUE(delegate.get_java_script_dialog_presenter_called());
+  EXPECT_TRUE(presenter.run_java_script_dialog_called());
+  EXPECT_TRUE(callback_called);
+
+  EXPECT_FALSE(presenter.cancel_active_and_pending_dialogs_called());
+  web_state_->CancelActiveAndPendingDialogs();
+  EXPECT_TRUE(presenter.cancel_active_and_pending_dialogs_called());
 }
 
 // Verifies that GlobalWebStateObservers are called when expected.
 TEST_F(WebStateTest, GlobalObserverTest) {
   std::unique_ptr<TestGlobalWebStateObserver> observer(
       new TestGlobalWebStateObserver());
 
   // Test that NavigationItemsPruned() is called.
   EXPECT_FALSE(observer->navigation_items_pruned_called());
   web_state_->OnNavigationItemsPruned(1);
@@ skipping 197 matching lines @@
       "</script>");
 
   base::test::ios::WaitUntilCondition(^{
     return message_received;
   });
   web_state_->RemoveScriptCommandCallback("test");
 }
 
 }  // namespace
 }  // namespace web