Convert Pass()→std::move() for iOS build.

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 <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"
@@ skipping 558 matching lines @@
     // Callers should create concrete subclasses instead.
     NOTREACHED();
     return nil;
   }
   return [super allocWithZone:zone];
 }
 
 - (instancetype)initWithWebState:(scoped_ptr<WebStateImpl>)webState {
   self = [super init];
   if (self) {
-    _webStateImpl = webState.Pass();
+    _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.
     _defaultURL = GURL(url::kAboutBlankURL);
     _jsInjectionReceiver.reset(
         [[CRWJSInjectionReceiver alloc] initWithEvaluator:self]);
@@ skipping 288 matching lines @@
   [self fetchDOMElementAtPoint:webViewPoint
              completionHandler:^(scoped_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 {
-  _DOMElementForLastTouch = element.Pass();
+  _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)
     return;
@@ skipping 961 matching lines @@
 
 - (void)evaluateJavaScript:(NSString*)script
          JSONResultHandler:
              (void (^)(scoped_ptr<base::Value>, NSError*))handler {
   [self evaluateJavaScript:script
        stringResultHandler:^(NSString* stringResult, NSError* error) {
          DCHECK(stringResult || error);
          if (handler) {
            scoped_ptr<base::Value> result(
                base::JSONReader::Read(base::SysNSStringToUTF8(stringResult)));
-           handler(result.Pass(), error);
+           handler(std::move(result), error);
          }
        }];
 }
 
 - (void)addGestureRecognizerToWebView:(UIGestureRecognizer*)recognizer {
   if ([_gestureRecognizers containsObject:recognizer])
     return;
 
   [self.webView addGestureRecognizer:recognizer];
   [_gestureRecognizers addObject:recognizer];
@@ skipping 1089 matching lines @@
 
   // 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:element.Pass()];
+               [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.
@@ skipping 569 matching lines @@
                  // 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(elementAsDict.Pass());
+                 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)) {
@@ skipping 309 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