Add public API for handling Javascript alerts and prompt.

ios/web/web_state/ui/crw_web_controller.mm

 // Copyright 2012 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.
 
 #import "ios/web/web_state/ui/crw_web_controller.h"
 
 #import <WebKit/WebKit.h>
 
 #import <objc/runtime.h>
 #include <stddef.h>
 
 #include <cmath>
 #include <memory>
 #include <utility>
 
+#include "base/callback.h"
 #include "base/containers/mru_cache.h"
 #include "base/ios/block_types.h"
 #include "base/ios/ios_util.h"
 #import "base/ios/ns_error_util.h"
 #include "base/ios/weak_nsobject.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
@@ skipping 819 matching lines @@
                  completionHandler:
                      (void (^)(NSURLSessionAuthChallengeDisposition,
                                NSURLCredential*))completionHandler;
 // Used in webView:didReceiveAuthenticationChallenge:completionHandler: to reply
 // with NSURLSessionAuthChallengeDisposition and credentials.
 + (void)processHTTPAuthForUser:(NSString*)user
                       password:(NSString*)password
              completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition,
                                          NSURLCredential*))completionHandler;
 
+// Helper to respond to |webView:runJavaScript...| delegate methods.

[Eugene But (OOO till 7-30), 2016/06/24 17:04:52]

Please document whether or not |completionHandler| can be nil. I think if you
disallow nil, then the code will be simpler.

[michaeldo, 2016/06/27 20:30:10]

you're right, made it non-nil.

+- (void)runJavaScriptDialogOfType:(web::JavaScriptMessageType)type
+                 initiatedByFrame:(WKFrameInfo*)frame
+                          message:(NSString*)message
+                      defaultText:(NSString*)defaultText
+                       completion:(void (^)(BOOL, NSString*))completionHandler;
+
 // Called when WKWebView estimatedProgress has been changed.
 - (void)webViewEstimatedProgressDidChange;
 // Called when WKWebView certificateChain or hasOnlySecureContent property has
 // changed.
 - (void)webViewSecurityFeaturesDidChange;
 // Called when WKWebView loading state has been changed.
 - (void)webViewLoadingStateDidChange;
 // Called when WKWebView title has been changed.
 - (void)webViewTitleDidChange;
 // Called when WKWebView URL has been changed.
@@ skipping 2845 matching lines @@
   if (self.shouldSuppressDialogs) {
     [self didSuppressDialog];
     completionHandler(NSURLSessionAuthChallengeRejectProtectionSpace, nil);
     return;
   }
 
   SEL selector = @selector(webController:
          runAuthDialogForProtectionSpace:
                       proposedCredential:
                        completionHandler:);
-  if (![self.UIDelegate respondsToSelector:selector]) {
-    // Embedder does not support HTTP Authentication.
-    completionHandler(NSURLSessionAuthChallengeRejectProtectionSpace, nil);
-    return;
+  if ([self.UIDelegate respondsToSelector:selector]) {
+    [self.UIDelegate webController:self
+        runAuthDialogForProtectionSpace:space
+                     proposedCredential:challenge.proposedCredential
+                      completionHandler:^(NSString* user, NSString* password) {
+                        [CRWWebController
+                            processHTTPAuthForUser:user
+                                          password:password
+                                 completionHandler:completionHandler];
+                      }];
+  } else {
+    void (^callback)(NSURLSessionAuthChallengeDisposition, NSURLCredential*) =
+        nil;
+    if (completionHandler) {
+      callback = [completionHandler copy];
+    }
+    self.webStateImpl->RunAuthDialog(
+        space, challenge.proposedCredential,
+        base::BindBlock(^(const net::AuthCredentials& credentials) {
+          if (callback) {
+            [CRWWebController processHTTPAuthForUser:base::SysUTF16ToNSString(
+                                                         credentials.username())
+                                            password:base::SysUTF16ToNSString(
+                                                         credentials.password())
+                                   completionHandler:callback];
+            [callback release];
+          }
+        }));
   }
-
-  [self.UIDelegate webController:self
-      runAuthDialogForProtectionSpace:space
-                   proposedCredential:challenge.proposedCredential
-                    completionHandler:^(NSString* user, NSString* password) {
-                      [CRWWebController
-                          processHTTPAuthForUser:user
-                                        password:password
-                               completionHandler:completionHandler];
-                    }];
 }
 
 + (void)processHTTPAuthForUser:(NSString*)user
                       password:(NSString*)password
              completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition,
                                          NSURLCredential*))completionHandler {
-  DCHECK_EQ(user == nil, password == nil);
   if (!user || !password) {
-    // Embedder cancelled authentication.
+    // Embedder cancelled authentication or embedder does not support HTTP
+    // Authentication.
     completionHandler(NSURLSessionAuthChallengeRejectProtectionSpace, nil);
     return;
   }
   completionHandler(
       NSURLSessionAuthChallengeUseCredential,
       [NSURLCredential
           credentialWithUser:user
                     password:password
                  persistence:NSURLCredentialPersistenceForSession]);
 }
 
 #pragma mark -
+#pragma mark JavaScript Dialog
+
+- (void)runJavaScriptDialogOfType:(web::JavaScriptMessageType)type
+                 initiatedByFrame:(WKFrameInfo*)frame
+                          message:(NSString*)message
+                      defaultText:(NSString*)defaultText
+                       completion:(void (^)(BOOL, NSString*))completionHandler {

[Eugene But (OOO till 7-30), 2016/06/24 17:04:52]

I think if you always pass |completionHandler| the code will be simpler. WDYT?

[michaeldo, 2016/06/27 20:30:10]

Agreed, made the completion handler required per your above recommendation.

+  void (^callback)(BOOL, NSString*) = nil;
+  if (completionHandler) {
+    callback = [completionHandler copy];

[Eugene But (OOO till 7-30), 2016/06/24 17:04:52]

Why do you need a separate |callback| variable? Can you just always use
completionHandler? 

[michaeldo, 2016/06/27 20:30:10]

Done.

+  }
+  self.webStateImpl->RunJavaScriptDialog(
+      net::GURLWithNSURL(frame.request.URL), type, message, defaultText,
+      base::BindBlock(^(bool success, NSString* input) {
+        if (callback) {
+          callback(success, input);
+          [callback release];
+        }
+      }));
+}
+
+#pragma mark -
 #pragma mark TouchTracking
 
 - (void)touched:(BOOL)touched {
   _clickInProgress = touched;
   if (touched) {
     self.userInteractionRegistered = YES;
     _userInteractedWithWebController = YES;
     if (_isBeingDestroyed)
       return;
     const web::NavigationManagerImpl& navigationManager =
@@ skipping 913 matching lines @@
   [self setDocumentURL:_defaultURL];
 }
 
 - (void)removeWebViewAllowingCachedReconstruction:(BOOL)allowCache {
   if (!_webView)
     return;
 
   SEL cancelDialogsSelector = @selector(cancelDialogsForWebController:);
   if ([self.UIDelegate respondsToSelector:cancelDialogsSelector])
     [self.UIDelegate cancelDialogsForWebController:self];
+  _webStateImpl->CancelActiveAndPendingDialogs();
 
   if (allowCache)
     _expectedReconstructionURL = [self currentNavigationURL];
   else
     _expectedReconstructionURL = GURL();
 
   [self abortLoad];
   [_webView removeFromSuperview];
   [_containerView resetContent];
   [self setWebView:nil];
 }
 
 - (void)webViewWebProcessDidCrash {
   _webProcessIsDead = YES;
 
   SEL cancelDialogsSelector = @selector(cancelDialogsForWebController:);
   if ([self.UIDelegate respondsToSelector:cancelDialogsSelector])
     [self.UIDelegate cancelDialogsForWebController:self];
+  _webStateImpl->CancelActiveAndPendingDialogs();
 
   SEL rendererCrashSelector = @selector(webControllerWebProcessDidCrash:);
   if ([self.delegate respondsToSelector:rendererCrashSelector])
     [self.delegate webControllerWebProcessDidCrash:self];
 }
 
 - (web::WKWebViewConfigurationProvider&)webViewConfigurationProvider {
   web::BrowserState* browserState = self.webStateImpl->GetBrowserState();
   return web::WKWebViewConfigurationProvider::FromBrowserState(browserState);
 }
@@ skipping 107 matching lines @@
     [self.delegate webPageOrderedClose];
   }
 }
 
 - (void)webView:(WKWebView*)webView
     runJavaScriptAlertPanelWithMessage:(NSString*)message
                       initiatedByFrame:(WKFrameInfo*)frame
                      completionHandler:(void (^)())completionHandler {
   if (self.shouldSuppressDialogs) {
     [self didSuppressDialog];
-    completionHandler();
+    if (completionHandler) {
+      completionHandler();
+    }
     return;
   }
 
   SEL alertSelector = @selector(webController:
            runJavaScriptAlertPanelWithMessage:
                                    requestURL:
                             completionHandler:);
   if ([self.UIDelegate respondsToSelector:alertSelector]) {
     [self.UIDelegate webController:self
         runJavaScriptAlertPanelWithMessage:message
                                 requestURL:net::GURLWithNSURL(frame.request.URL)
                          completionHandler:completionHandler];
-  } else if (completionHandler) {
-    completionHandler();
+  } else {
+    void (^completion)(BOOL, NSString*) = nil;
+    if (completionHandler) {
+      completion = ^(BOOL, NSString*) {
+        completionHandler();
+      };
+    }
+    [self runJavaScriptDialogOfType:web::JAVASCRIPT_MESSAGE_TYPE_ALERT
+                   initiatedByFrame:frame
+                            message:message
+                        defaultText:nil
+                         completion:completion];
   }
 }
 
 - (void)webView:(WKWebView*)webView
     runJavaScriptConfirmPanelWithMessage:(NSString*)message
                         initiatedByFrame:(WKFrameInfo*)frame
                        completionHandler:
                            (void (^)(BOOL result))completionHandler {
   if (self.shouldSuppressDialogs) {
     [self didSuppressDialog];
     completionHandler(NO);
     return;
   }
 
   SEL confirmationSelector = @selector(webController:
                 runJavaScriptConfirmPanelWithMessage:
                                           requestURL:
                                    completionHandler:);
   if ([self.UIDelegate respondsToSelector:confirmationSelector]) {
     [self.UIDelegate webController:self
         runJavaScriptConfirmPanelWithMessage:message
                                   requestURL:net::GURLWithNSURL(
                                                  frame.request.URL)
                            completionHandler:completionHandler];
-  } else if (completionHandler) {
-    completionHandler(NO);
+  } else {
+    void (^completion)(BOOL, NSString*) = nil;
+    if (completionHandler) {
+      completion = ^(BOOL success, NSString*) {
+        completionHandler(success);
+      };
+    }
+    [self runJavaScriptDialogOfType:web::JAVASCRIPT_MESSAGE_TYPE_CONFIRM
+                   initiatedByFrame:frame
+                            message:message
+                        defaultText:nil
+                         completion:completion];
   }
 }
 
 - (void)webView:(WKWebView*)webView
     runJavaScriptTextInputPanelWithPrompt:(NSString*)prompt
                               defaultText:(NSString*)defaultText
                          initiatedByFrame:(WKFrameInfo*)frame
                         completionHandler:
                             (void (^)(NSString* result))completionHandler {
   GURL origin(web::GURLOriginWithWKSecurityOrigin(frame.securityOrigin));
@@ skipping 16 matching lines @@
                                       defaultText:
                                        requestURL:
                                 completionHandler:);
   if ([self.UIDelegate respondsToSelector:textInputSelector]) {
     GURL requestURL = net::GURLWithNSURL(frame.request.URL);
     [self.UIDelegate webController:self
         runJavaScriptTextInputPanelWithPrompt:prompt
                                   defaultText:defaultText
                                    requestURL:requestURL
                             completionHandler:completionHandler];
-  } else if (completionHandler) {
-    completionHandler(nil);
+  } else {
+    void (^completion)(BOOL, NSString*) = nil;
+    if (completionHandler) {
+      completion = ^(BOOL, NSString* input) {
+        completionHandler(input);
+      };
+    }
+    [self runJavaScriptDialogOfType:web::JAVASCRIPT_MESSAGE_TYPE_PROMPT
+                   initiatedByFrame:frame
+                            message:prompt
+                        defaultText:defaultText
+                         completion:completion];
   }
 }
 
 #pragma mark -
 #pragma mark WKNavigationDelegate Methods
 
 - (void)webView:(WKWebView*)webView
     decidePolicyForNavigationAction:(WKNavigationAction*)action
                     decisionHandler:
                         (void (^)(WKNavigationActionPolicy))decisionHandler {
@@ skipping 666 matching lines @@
   }
 
   return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
 }
 
 - (NSString*)refererFromNavigationAction:(WKNavigationAction*)action {
   return [action.request valueForHTTPHeaderField:@"Referer"];
 }
 
 @end