Upstream ios/web_view source code.

ios/web_view/internal/criwv_web_view_impl.mm

Index: ios/web_view/internal/criwv_web_view_impl.mm
diff --git a/ios/web_view/internal/criwv_web_view_impl.mm b/ios/web_view/internal/criwv_web_view_impl.mm
new file mode 100644
index 0000000000000000000000000000000000000000..84b29389f310fbc8a192efad394300b25a3dcaf3
--- /dev/null
+++ b/ios/web_view/internal/criwv_web_view_impl.mm
@@ -0,0 +1,251 @@
+// 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.
+
+#import "ios/web_view/internal/criwv_web_view_impl.h"
+
+#include <memory>
+#include <utility>
+
+#import "base/ios/weak_nsobject.h"
+#include "base/strings/sys_string_conversions.h"
+#import "ios/web/navigation/crw_session_controller.h"
+#include "ios/web/public/referrer.h"
+#import "ios/web/public/navigation_manager.h"
+#import "ios/web/public/web_state/ui/crw_web_delegate.h"
+#import "ios/web/public/web_state/web_state.h"
+#import "ios/web/public/web_state/web_state_delegate_bridge.h"
+#import "ios/web/web_state/ui/crw_web_controller.h"
+#import "ios/web/web_state/web_state_impl.h"
+#include "ios/web_view/internal/criwv_browser_state.h"
+#import "ios/web_view/internal/translate/criwv_translate_client.h"
+#import "ios/web_view/public/criwv_web_view_delegate.h"
+#import "net/base/mac/url_conversions.h"
+#include "ui/base/page_transition_types.h"
+#include "url/gurl.h"
+
+@interface CRIWVWebViewImpl ()<CRWWebDelegate, CRWWebStateDelegate> {
+  id<CRIWVWebViewDelegate> _delegate;
+  ios_web_view::CRIWVBrowserState* _browserState;
+  std::unique_ptr<web::WebStateImpl> _webStateImpl;
+  base::WeakNSObject<CRWWebController> _webController;
+  std::unique_ptr<web::WebStateDelegateBridge> _webStateDelegate;
+
+  CGFloat _loadProgress;
+}
+
+// Returns the web state associated with this web view.
+- (web::WebState*)webState;
+
+@end
+
+@implementation CRIWVWebViewImpl
+
+@synthesize delegate = _delegate;
+@synthesize loadProgress = _loadProgress;
+
+- (instancetype)initWithBrowserState:
+    (ios_web_view::CRIWVBrowserState*)browserState {
+  self = [super init];
+  if (self) {
+    _browserState = browserState;
+    _webStateImpl.reset(new web::WebStateImpl(_browserState));

[sdefresne, 2017/01/20 10:28:13]

nit: _webStateImpl = base::MakeUnique<web::WebStateImpl>(_browserState);

[michaeldo, 2017/01/24 22:35:26]

Done in dep CL.

+    _webStateImpl->GetNavigationManagerImpl().InitializeSession(nil, nil, NO,
+                                                                0);
+    _webStateDelegate.reset(new web::WebStateDelegateBridge(self));

[sdefresne, 2017/01/20 10:28:13]

nit: _webStateDelegate = base::MakeUnique<web::WebStateDelegateBridge>(self);

[michaeldo, 2017/01/24 22:35:25]

Done in dep CL.

+    _webStateImpl->SetDelegate(_webStateDelegate.get());
+    _webController.reset(_webStateImpl->GetWebController());
+    [_webController setDelegate:self];
+    [_webController setWebUsageEnabled:YES];
+
+    // Initialize Translate.
+    web::WebState* webState = [_webController webStateImpl];
+    ios_web_view::CRIWVTranslateClient::CreateForWebState(webState);
+  }
+  return self;
+}
+
+- (web::WebState*)webState {
+  // TODO(crbug.com/679895): Stop using the private CRWWebController API.

[sdefresne, 2017/01/20 10:28:13]

I think you can fix this TODO easily by changing this method to the following
implementation:

- (web::WebState*)webState {
  return )webStateImpl.get();
}

[michaeldo, 2017/01/24 22:35:25]

Done in dep CL.

+  return [_webController webStateImpl];
+}
+
+- (UIView*)view {
+  return [_webController view];
+}
+
+- (BOOL)canGoBack {
+  return _webStateImpl && _webStateImpl->GetNavigationManager()->CanGoBack();
+}
+
+- (BOOL)canGoForward {
+  return _webStateImpl && _webStateImpl->GetNavigationManager()->CanGoForward();
+}
+
+- (BOOL)isLoading {
+  return [_webController webStateImpl]->IsLoading();

[sdefresne, 2017/01/20 10:28:13]

ditto, here you should be able to just use _webStateImpl directly:

- (BOOL)isLoading {
  return _webStateImpl->IsLoading();
}

[michaeldo, 2017/01/24 22:35:26]

Done in dep CL.

+}
+
+- (NSURL*)visibleURL {
+  return net::NSURLWithGURL([self webState]->GetVisibleURL());

[sdefresne, 2017/01/20 10:28:13]

nit: use "self.webState" instead of "[self webState]"

BTW, I think you should be consistent and use either "self.webState" everywhere
or use "_webStateImpl".

[michaeldo, 2017/01/24 22:35:25]

Agreed, done in dep CL.

+}
+
+- (NSString*)pageTitle {

[sdefresne, 2017/01/20 10:28:13]

ditto, here you should be able to just use _webStateImpl directly:

- (NSString*)pageTitle {
  return _webStateImpl->GetTitle();
}

[michaeldo, 2017/01/24 22:35:26]

Done in dep CL.

+  return base::SysUTF16ToNSString([_webController webStateImpl]->GetTitle());
+}
+
+- (void)goBack {
+  if (_webStateImpl)

[sdefresne, 2017/01/20 10:28:13]

Why check whether _webStateImpl can be null here and not in other methods (like
visibleURL for example). AFAICT from reading the code, _webStateImpl is owned by
self, is a private ivar so no sub-class should be able to change it, and is
never reset outside of the initializer, so this ivar *cannot* be null and the
check is useless.

I think you should remove it, or change it to a check that
_webStateImpl->GetNavigationManager() is not null (which would make more sense).

[michaeldo, 2017/01/24 22:35:26]

In dep CL, I updated the check for the navigationManager. The check isn't useful
now, but is consistent with canGoBack/Forward and may be useful so I'll leave it
for now.

+    _webStateImpl->GetNavigationManager()->GoBack();
+}
+
+- (void)goForward {
+  if (_webStateImpl)

[sdefresne, 2017/01/20 10:28:13]

ditto

[michaeldo, 2017/01/24 22:35:25]

Done in dep CL.

+    _webStateImpl->GetNavigationManager()->GoForward();
+}
+
+- (void)reload {
+  [_webController reload];
+}
+
+- (void)stopLoading {
+  [_webController stopLoading];
+}
+
+- (void)loadURL:(NSURL*)URL {
+  web::NavigationManager::WebLoadParams params(net::GURLWithNSURL(URL));
+  params.transition_type = ui::PAGE_TRANSITION_TYPED;
+  [_webController loadWithParams:params];
+}
+
+- (void)evaluateJavaScript:(NSString*)javaScriptString
+         completionHandler:(void (^)(id, NSError*))completionHandler {
+  [[self webState]->GetJSInjectionReceiver()

[sdefresne, 2017/01/20 10:28:12]

s/[self webState]/self.webState/ or s/[self webState]/_webStateImpl/

[michaeldo, 2017/01/24 22:35:26]

Done in dep CL.

+      executeJavaScript:javaScriptString
+      completionHandler:completionHandler];
+}
+
+- (void)setDelegate:(id<CRIWVWebViewDelegate>)delegate {
+  _delegate = delegate;
+
+  // Set up the translate delegate.

[sdefresne, 2017/01/20 10:28:13]

nit:, I would first check whether _delegate responds to -translateDelegate
selector, like this

  // Set up the translate delegate.
  if ([_delegate respondsToSelector:@selector(translateDelegate)]) {
    id<CRWVTranslateDelegate> translateDelegate = [_delegate translateDelegate];
    ios_web_view::CRIWVTranslateClient::FromWebState(_webStateImpl.get())
        ->set_translate_delegate(translateDelegate);
  }

[michaeldo, 2017/01/24 22:35:26]

I think the way it is now may be better since it will ensure the translate
delegate is set to nil in the case where translate is not implemented in the
delegate. By changing it, if the delegate is changed, the old delegate's
translateDelegate may still get calls.

[sdefresne, 2017/01/25 09:13:26]

Acknowdleged. I didn't think of that edge case. Thank you.

+  ios_web_view::CRIWVTranslateClient* translateClient =
+      ios_web_view::CRIWVTranslateClient::FromWebState([self webState]);

[sdefresne, 2017/01/20 10:28:13]

ditto, self.webState

[michaeldo, 2017/01/24 22:35:26]

Done in dep CL.

+  id<CRIWVTranslateDelegate> translateDelegate = nil;
+  if ([_delegate respondsToSelector:@selector(translateDelegate)])
+    translateDelegate = [_delegate translateDelegate];
+  translateClient->set_translate_delegate(translateDelegate);
+}
+
+// -----------------------------------------------------------------------
+// WebDelegate implementation.
+
+- (void)notifyDidUpdateWithChanges:(CRIWVWebViewUpdateType)changes {
+  SEL selector = @selector(webView:didUpdateWithChanges:);
+  if ([_delegate respondsToSelector:selector]) {
+    [_delegate webView:self didUpdateWithChanges:changes];
+  }
+}
+
+- (void)webController:(CRWWebController*)webController
+       titleDidChange:(NSString*)title {
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeTitle];
+}
+
+- (void)webDidUpdateSessionForLoadWithParams:
+            (const web::NavigationManager::WebLoadParams&)params
+                        wasInitialNavigation:(BOOL)initialNavigation {
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeURL];
+}
+
+- (void)webWillFinishHistoryNavigationFromEntry:(CRWSessionEntry*)fromEntry {
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeURL];
+}
+
+- (void)webDidAddPendingURL {
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeURL];
+}
+
+- (void)webDidUpdateHistoryStateWithPageURL:(const GURL&)pageUrl {
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeURL];
+}
+
+- (void)webCancelStartLoadingRequest {
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeURL];
+}
+
+- (void)webDidStartLoadingURL:(const GURL&)currentUrl
+          shouldUpdateHistory:(BOOL)updateHistory {
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeURL];
+}
+
+- (void)webDidFinishWithURL:(const GURL&)url loadSuccess:(BOOL)loadSuccess {
+  SEL selector = @selector(webView:didFinishLoadingWithURL:loadSuccess:);
+  if ([_delegate respondsToSelector:selector]) {
+    [_delegate webView:self
+        didFinishLoadingWithURL:net::NSURLWithGURL(url)
+                    loadSuccess:loadSuccess];
+  }
+}
+
+- (void)webLoadCancelled:(const GURL&)url {
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeURL];
+}
+
+- (void)webWillAddPendingURL:(const GURL&)url
+                  transition:(ui::PageTransition)transition {
+}
+- (CRWWebController*)webPageOrderedOpen:(const GURL&)url
+                               referrer:(const web::Referrer&)referrer
+                             windowName:(NSString*)windowName
+                           inBackground:(BOOL)inBackground {
+  return nil;
+}
+
+- (CRWWebController*)webPageOrderedOpen {
+  return nil;
+}
+
+- (void)webPageOrderedClose {
+}
+- (void)openURLWithParams:(const web::WebState::OpenURLParams&)params {
+}
+- (BOOL)openExternalURL:(const GURL&)url linkClicked:(BOOL)linkClicked {
+  return NO;
+}
+- (void)webController:(CRWWebController*)webController
+    retrievePlaceholderOverlayImage:(void (^)(UIImage*))block {
+}
+- (void)webController:(CRWWebController*)webController
+    onFormResubmissionForRequest:(NSURLRequest*)request
+                   continueBlock:(ProceduralBlock)continueBlock
+                     cancelBlock:(ProceduralBlock)cancelBlock {
+}
+- (void)webWillReload {
+}
+- (void)webWillInitiateLoadWithParams:
+    (web::NavigationManager::WebLoadParams&)params {
+}
+- (BOOL)webController:(CRWWebController*)webController
+        shouldOpenURL:(const GURL&)url
+      mainDocumentURL:(const GURL&)mainDocumentURL
+          linkClicked:(BOOL)linkClicked {
+  SEL selector = @selector(webView:shouldOpenURL:mainDocumentURL:linkClicked:);
+  if ([_delegate respondsToSelector:selector]) {
+    return [_delegate webView:self
+                shouldOpenURL:net::NSURLWithGURL(url)
+              mainDocumentURL:net::NSURLWithGURL(mainDocumentURL)
+                  linkClicked:linkClicked];
+  }
+  return YES;
+}
+
+// -----------------------------------------------------------------------
+// CRWWebStateDelegate implementation.
+
+- (void)webState:(web::WebState*)webState didChangeProgress:(double)progress {
+  _loadProgress = progress;
+  [self notifyDidUpdateWithChanges:CRIWVWebViewUpdateTypeProgress];
+}
+
+@end