Convert //ios from scoped_ptr to std::unique_ptr.

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 <objc/runtime.h>
 #include <stddef.h>
 
 #include <cmath>
+#include <memory>
 #include <utility>
 
 #include "base/ios/block_types.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/bundle_locations.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/objc_property_releaser.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/prefs/pref_service.h"
 #include "components/url_formatter/url_formatter.h"
 #import "ios/net/nsurlrequest_util.h"
 #include "ios/public/provider/web/web_ui_ios.h"
 #import "ios/web/crw_network_activity_indicator_manager.h"
 #import "ios/web/history_state_util.h"
 #include "ios/web/interstitials/web_interstitial_impl.h"
 #import "ios/web/navigation/crw_session_certificate_policy_manager.h"
 #import "ios/web/navigation/crw_session_controller.h"
 #import "ios/web/navigation/crw_session_entry.h"
 #import "ios/web/navigation/navigation_item_impl.h"
 #import "ios/web/navigation/navigation_manager_impl.h"
 #include "ios/web/net/request_group_util.h"
 #include "ios/web/public/browser_state.h"
 #include "ios/web/public/favicon_url.h"
+#include "ios/web/public/navigation_item.h"
 #import "ios/web/public/navigation_manager.h"
-#include "ios/web/public/navigation_item.h"
 #include "ios/web/public/referrer.h"
 #include "ios/web/public/referrer_util.h"
 #include "ios/web/public/ssl_status.h"
 #import "ios/web/public/url_scheme_util.h"
 #include "ios/web/public/url_util.h"
 #include "ios/web/public/user_metrics.h"
 #include "ios/web/public/web_client.h"
 #include "ios/web/public/web_kit_constants.h"
 #include "ios/web/public/web_state/credential.h"
 #import "ios/web/public/web_state/crw_web_controller_observer.h"
 #import "ios/web/public/web_state/crw_web_view_scroll_view_proxy.h"
 #import "ios/web/public/web_state/js/credential_util.h"
 #import "ios/web/public/web_state/js/crw_js_injection_manager.h"
 #import "ios/web/public/web_state/js/crw_js_injection_receiver.h"
 #import "ios/web/public/web_state/ui/crw_content_view.h"
 #import "ios/web/public/web_state/ui/crw_native_content.h"
 #import "ios/web/public/web_state/ui/crw_native_content_provider.h"
 #import "ios/web/public/web_state/ui/crw_web_view_content_view.h"
 #include "ios/web/public/web_state/url_verification_constants.h"
 #include "ios/web/public/web_state/web_state.h"
 #include "ios/web/web_state/blocked_popup_info.h"
 #import "ios/web/web_state/crw_web_view_proxy_impl.h"
 #import "ios/web/web_state/error_translation_util.h"
 #include "ios/web/web_state/frame_info.h"
-#import "ios/web/web_state/page_viewport_state.h"
 #import "ios/web/web_state/js/crw_js_early_script_manager.h"
 #import "ios/web/web_state/js/crw_js_plugin_placeholder_manager.h"
 #import "ios/web/web_state/js/crw_js_window_id_manager.h"
+#import "ios/web/web_state/page_viewport_state.h"
 #import "ios/web/web_state/ui/crw_context_menu_provider.h"
 #import "ios/web/web_state/ui/crw_swipe_recognizer_provider.h"
 #import "ios/web/web_state/ui/crw_web_controller+protected.h"
 #import "ios/web/web_state/ui/crw_web_controller_container_view.h"
 #import "ios/web/web_state/ui/crw_wk_web_view_web_controller.h"
 #import "ios/web/web_state/web_controller_observer_bridge.h"
 #include "ios/web/web_state/web_state_facade_delegate.h"
 #import "ios/web/web_state/web_state_impl.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/base/net_errors.h"
@@ skipping 152 matching lines @@
   // The touch tracking recognizer allowing us to decide if a navigation is
   // started by the user.
   base::scoped_nsobject<CRWTouchTrackingRecognizer> _touchTrackingRecognizer;
   // Long press recognizer that allows showing context menus.
   base::scoped_nsobject<UILongPressGestureRecognizer> _contextMenuRecognizer;
   // DOM element information for the point where the user made the last touch.
   // Can be null if has not been calculated yet. Precalculation is necessary
   // because retreiving DOM element relies on async API so element info can not
   // be built on demand. May contain the following keys: "href", "src", "title",
   // "referrerPolicy". All values are strings. Used for showing context menus.
-  scoped_ptr<base::DictionaryValue> _DOMElementForLastTouch;
+  std::unique_ptr<base::DictionaryValue> _DOMElementForLastTouch;
   // Whether a click is in progress.
   BOOL _clickInProgress;
   // Data on the recorded last user interaction.
-  scoped_ptr<web::UserInteractionEvent> _lastUserInteraction;
+  std::unique_ptr<web::UserInteractionEvent> _lastUserInteraction;
   // YES if there has been user interaction with views owned by this controller.
   BOOL _userInteractedWithWebController;
   // The time of the last page transfer start, measured in seconds since Jan 1
   // 2001.
   CFAbsoluteTime _lastTransferTimeInSeconds;
   // Default URL (about:blank).
   GURL _defaultURL;
   // Show overlay view, don't reload web page.
   BOOL _overlayPreviewMode;
   // If |YES|, calls |setShouldSuppressDialogs:YES| when window id is injected
   // into the web view.
   BOOL _shouldSuppressDialogsOnWindowIDInjection;
   // The URL of an expected future recreation of the |webView|. Valid
   // only if the web view was discarded for non-user-visible reasons, such that
   // if the next load request is for that URL, it should be treated as a
   // reconstruction that should use cache aggressively.
   GURL _expectedReconstructionURL;
   // Whether the web page is currently performing window.history.pushState or
   // window.history.replaceState
   // Set to YES on window.history.willChangeState message. To NO on
   // window.history.didPushState or window.history.didReplaceState.
   BOOL _changingHistoryState;
 
-  scoped_ptr<web::NewWindowInfo> _externalRequest;
+  std::unique_ptr<web::NewWindowInfo> _externalRequest;
 
   // The WebStateImpl instance associated with this CRWWebController.
-  scoped_ptr<WebStateImpl> _webStateImpl;
+  std::unique_ptr<WebStateImpl> _webStateImpl;
 
   // A set of URLs opened in external applications; stored so that errors
   // from the web view can be identified as resulting from these events.
   base::scoped_nsobject<NSMutableSet> _openedApplicationURL;
 
   // Object that manages all early script injection into the web view.
   base::scoped_nsobject<CRWJSEarlyScriptManager> _earlyScriptManager;
 
   // Script manager for setting the windowID.
   base::scoped_nsobject<CRWJSWindowIdManager> _windowIDJSManager;
@@ skipping 51 matching lines @@
 - (BOOL)shouldClosePageOnNativeApplicationLoad;
 // Called after URL is finished loading and _loadPhase is set to PAGE_LOADED.
 - (void)didFinishWithURL:(const GURL&)currentURL loadSuccess:(BOOL)loadSuccess;
 // Informs the native controller if web usage is allowed or not.
 - (void)setNativeControllerWebUsageEnabled:(BOOL)webUsageEnabled;
 // Evaluates the supplied JavaScript in the web view. Calls |handler| with
 // results of the evaluation (which may be nil if the implementing object has no
 // way to run the evaluation or the evaluation returns a nil value) or an
 // NSError if there is an error. The |handler| can be nil.
 - (void)evaluateJavaScript:(NSString*)script
-         JSONResultHandler:(void (^)(scoped_ptr<base::Value>, NSError*))handler;
+         JSONResultHandler:
+             (void (^)(std::unique_ptr<base::Value>, NSError*))handler;
 // Attempts to handle a script message. Returns YES on success, NO otherwise.
 - (BOOL)respondToWKScriptMessage:(WKScriptMessage*)scriptMessage;
 // Generates the JavaScript string used to update the UIWebView's URL so that it
 // matches the URL displayed in the omnibox and sets window.history.state to
 // stateObject. Needed for history.pushState() and history.replaceState().
 - (NSString*)javascriptToReplaceWebViewURL:(const GURL&)URL
                            stateObjectJSON:(NSString*)stateObject;
 // Injects JavaScript into the web view to update the URL to |URL|, to set
 // window.history.state to |stateObject|, and to trigger a popstate() event.
 // Upon the scripts completion, resets |urlOnStartLoading_| and
@@ skipping 26 matching lines @@
 // Sets scroll offset value for webview scroll view from |scrollState|.
 - (void)applyWebViewScrollOffsetFromScrollState:
     (const web::PageScrollState&)scrollState;
 // Asynchronously fetches full width of the rendered web page.
 - (void)fetchWebPageWidthWithCompletionHandler:(void (^)(CGFloat))handler;
 // Asynchronously fetches information about DOM element for the given point (in
 // UIView coordinates). |handler| can not be nil. See |_DOMElementForLastTouch|
 // for element format description.
 - (void)fetchDOMElementAtPoint:(CGPoint)point
              completionHandler:
-                 (void (^)(scoped_ptr<base::DictionaryValue>))handler;
+                 (void (^)(std::unique_ptr<base::DictionaryValue>))handler;
 // Extracts context menu information from the given DOM element.
 // result keys are defined in crw_context_menu_provider.h.
 - (NSDictionary*)contextMenuInfoForElement:(base::DictionaryValue*)element;
 // Sets the value of |_DOMElementForLastTouch|.
-- (void)setDOMElementForLastTouch:(scoped_ptr<base::DictionaryValue>)element;
+- (void)setDOMElementForLastTouch:
+    (std::unique_ptr<base::DictionaryValue>)element;
 // Called when the window has determined there was a long-press and context menu
 // must be shown.
 - (void)showContextMenu:(UIGestureRecognizer*)gestureRecognizer;
 // YES if delegate supports showing context menu by responding to
 // webController:runContextMenu:atPoint:inView: selector.
 - (BOOL)supportsCustomContextMenu;
 // Cancels all touch events in the web view (long presses, tapping, scrolling).
 - (void)cancelAllTouches;
 // Returns the referrer for the current page.
 - (web::Referrer)currentReferrer;
@@ skipping 153 matching lines @@
 + (instancetype)allocWithZone:(struct _NSZone*)zone {
   if (self == [CRWWebController class]) {
     // This is an abstract class which should not be instantiated directly.
     // Callers should create concrete subclasses instead.
     NOTREACHED();
     return nil;
   }
   return [super allocWithZone:zone];
 }
 
-- (instancetype)initWithWebState:(scoped_ptr<WebStateImpl>)webState {
+- (instancetype)initWithWebState:(std::unique_ptr<WebStateImpl>)webState {
   self = [super init];
   if (self) {
     _webStateImpl = std::move(webState);
     DCHECK(_webStateImpl);
     _webStateImpl->SetWebController(self);
     _webStateImpl->InitializeRequestTracker(self);
     // Load phase when no WebView present is 'loaded' because this represents
     // the idle state.
     _loadPhase = web::PAGE_LOADED;
     // Content area is lazily instantiated.
@@ skipping 283 matching lines @@
 
   // Tear down web ui (in case this is part of this tab) and web state now,
   // since the timing of dealloc can't be guaranteed.
   _webStateImpl.reset();
 }
 
 - (void)checkLinkPresenceUnderGesture:(UIGestureRecognizer*)gestureRecognizer
                     completionHandler:(void (^)(BOOL))completionHandler {
   CGPoint webViewPoint = [gestureRecognizer locationInView:self.webView];
   base::WeakNSObject<CRWWebController> weakSelf(self);
-  [self fetchDOMElementAtPoint:webViewPoint
-             completionHandler:^(scoped_ptr<base::DictionaryValue> element) {
-               std::string link;
-               BOOL hasLink =
-                   element && element->GetString("href", &link) && link.size();
-               completionHandler(hasLink);
-             }];
+  [self
+      fetchDOMElementAtPoint:webViewPoint
+           completionHandler:^(std::unique_ptr<base::DictionaryValue> element) {
+             std::string link;
+             BOOL hasLink =
+                 element && element->GetString("href", &link) && link.size();
+             completionHandler(hasLink);
+           }];
 }
 
-- (void)setDOMElementForLastTouch:(scoped_ptr<base::DictionaryValue>)element {
+- (void)setDOMElementForLastTouch:
+    (std::unique_ptr<base::DictionaryValue>)element {
   _DOMElementForLastTouch = std::move(element);
 }
 
 - (void)showContextMenu:(UIGestureRecognizer*)gestureRecognizer {
   // Calling this method if [self supportsCustomContextMenu] returned NO
   // is a programmer error.
   DCHECK([self supportsCustomContextMenu]);
 
   // We don't want ongoing notification that the long press is held.
   if ([gestureRecognizer state] != UIGestureRecognizerStateBegan)
@@ skipping 944 matching lines @@
 
   url::StringPieceReplacements<std::string> emptyRef;
   emptyRef.SetRefStr("");
   GURL newEndURL = endURL.ReplaceComponents(emptyRef);
   toItem->SetURL(newEndURL);
   return newEndURL;
 }
 
 - (void)evaluateJavaScript:(NSString*)script
          JSONResultHandler:
-             (void (^)(scoped_ptr<base::Value>, NSError*))handler {
+             (void (^)(std::unique_ptr<base::Value>, NSError*))handler {
   [self evaluateJavaScript:script
        stringResultHandler:^(NSString* stringResult, NSError* error) {
          DCHECK(stringResult || error);
          if (handler) {
-           scoped_ptr<base::Value> result(
+           std::unique_ptr<base::Value> result(
                base::JSONReader::Read(base::SysNSStringToUTF8(stringResult)));
            handler(std::move(result), error);
          }
        }];
 }
 
 - (void)addGestureRecognizerToWebView:(UIGestureRecognizer*)recognizer {
   if ([_gestureRecognizers containsObject:recognizer])
     return;
 
@@ skipping 253 matching lines @@
   // Broken out into separate method to catch errors.
   if (![self respondToWKScriptMessage:message]) {
     DLOG(WARNING) << "Message from JS not handled due to invalid format";
   }
 }
 
 - (BOOL)respondToWKScriptMessage:(WKScriptMessage*)scriptMessage {
   CHECK(scriptMessage.frameInfo.mainFrame);
   int errorCode = 0;
   std::string errorMessage;
-  scoped_ptr<base::Value> inputJSONData(base::JSONReader::ReadAndReturnError(
-      base::SysNSStringToUTF8(scriptMessage.body), false, &errorCode,
-      &errorMessage));
+  std::unique_ptr<base::Value> inputJSONData(
+      base::JSONReader::ReadAndReturnError(
+          base::SysNSStringToUTF8(scriptMessage.body), false, &errorCode,
+          &errorMessage));
   if (errorCode) {
     DLOG(WARNING) << "JSON parse error: %s" << errorMessage.c_str();
     return NO;
   }
   base::DictionaryValue* message = nullptr;
   if (!inputJSONData->GetAsDictionary(&message)) {
     return NO;
   }
   std::string windowID;
   message->GetString("crwWindowId", &windowID);
@@ skipping 886 matching lines @@
     return YES;
   }
 
   // This is custom long press gesture recognizer. By the time the gesture is
   // recognized the web controller needs to know if there is a link under the
   // touch. If there a link, the web controller will reject system's context
   // menu and show another one. If for some reason context menu info is not
   // fetched - system context menu will be shown.
   [self setDOMElementForLastTouch:nullptr];
   base::WeakNSObject<CRWWebController> weakSelf(self);
-  [self fetchDOMElementAtPoint:[touch locationInView:self.webView]
-             completionHandler:^(scoped_ptr<base::DictionaryValue> element) {
-               [weakSelf setDOMElementForLastTouch:std::move(element)];
-             }];
+  [self
+      fetchDOMElementAtPoint:[touch locationInView:self.webView]
+           completionHandler:^(std::unique_ptr<base::DictionaryValue> element) {
+             [weakSelf setDOMElementForLastTouch:std::move(element)];
+           }];
   return YES;
 }
 
 - (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer*)gestureRecognizer {
   // Expect only _contextMenuRecognizer.
   DCHECK([gestureRecognizer isEqual:_contextMenuRecognizer]);
   if (!self.webView || ![self supportsCustomContextMenu]) {
     // Show the context menu iff currently displaying a web view.
     // Do nothing for native views.
     return NO;
@@ skipping 538 matching lines @@
   }
 
   [self evaluateJavaScript:@"__gCrWeb.getPageWidth();"
        stringResultHandler:^(NSString* pageWidthAsString, NSError*) {
          handler([pageWidthAsString floatValue]);
        }];
 }
 
 - (void)fetchDOMElementAtPoint:(CGPoint)point
              completionHandler:
-                 (void (^)(scoped_ptr<base::DictionaryValue>))handler {
+                 (void (^)(std::unique_ptr<base::DictionaryValue>))handler {
   DCHECK(handler);
   // Convert point into web page's coordinate system (which may be scaled and/or
   // scrolled).
   CGPoint scrollOffset = self.scrollPosition;
   CGFloat webViewContentWidth = self.webScrollView.contentSize.width;
   base::WeakNSObject<CRWWebController> weakSelf(self);
   [self fetchWebPageWidthWithCompletionHandler:^(CGFloat pageWidth) {
     CGFloat scale = pageWidth / webViewContentWidth;
     CGPoint localPoint = CGPointMake((point.x + scrollOffset.x) * scale,
                                      (point.y + scrollOffset.y) * scale);
     NSString* const kGetElementScript =
         [NSString stringWithFormat:@"__gCrWeb.getElementFromPoint(%g, %g);",
                                    localPoint.x, localPoint.y];
-    [weakSelf evaluateJavaScript:kGetElementScript
-               JSONResultHandler:^(scoped_ptr<base::Value> element, NSError*) {
-                 // Release raw element and call handler with DictionaryValue.
-                 scoped_ptr<base::DictionaryValue> elementAsDict;
-                 if (element) {
-                   base::DictionaryValue* elementAsDictPtr = nullptr;
-                   element.release()->GetAsDictionary(&elementAsDictPtr);
-                   // |rawElement| and |elementPtr| now point to the same
-                   // memory. |elementPtr| ownership will be transferred to
-                   // |element| scoped_ptr.
-                   elementAsDict.reset(elementAsDictPtr);
-                 }
-                 handler(std::move(elementAsDict));
-               }];
+    [weakSelf
+        evaluateJavaScript:kGetElementScript
+         JSONResultHandler:^(std::unique_ptr<base::Value> element, NSError*) {
+           // Release raw element and call handler with DictionaryValue.
+           std::unique_ptr<base::DictionaryValue> elementAsDict;
+           if (element) {
+             base::DictionaryValue* elementAsDictPtr = nullptr;
+             element.release()->GetAsDictionary(&elementAsDictPtr);
+             // |rawElement| and |elementPtr| now point to the same
+             // memory. |elementPtr| ownership will be transferred to
+             // |element| scoped_ptr.
+             elementAsDict.reset(elementAsDictPtr);
+           }
+           handler(std::move(elementAsDict));
+         }];
   }];
 }
 
 - (NSDictionary*)contextMenuInfoForElement:(base::DictionaryValue*)element {
   DCHECK(element);
   NSMutableDictionary* mutableInfo = [NSMutableDictionary dictionary];
   NSString* title = nil;
   std::string href;
   if (element->GetString("href", &href)) {
     mutableInfo[web::kContextLinkURLString] = base::SysUTF8ToNSString(href);
@@ skipping 303 matching lines @@
   if ([MIMEType isEqualToString:@"text/html"] ||
       [MIMEType isEqualToString:@"application/xhtml+xml"] ||
       [MIMEType isEqualToString:@"application/xml"]) {
     return web::WEB_VIEW_DOCUMENT_TYPE_HTML;
   }
 
   return web::WEB_VIEW_DOCUMENT_TYPE_GENERIC;
 }
 
 @end