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

ios/chrome/browser/passwords/password_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/chrome/browser/passwords/password_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #import "base/ios/weak_nsobject.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_nsobject.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_form_fill_data.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/infobars/core/infobar_manager.h"
 #include "components/password_manager/core/browser/password_bubble_experiment.h"
 #include "components/password_manager/core/browser/password_generation_manager.h"
 #include "components/password_manager/core/browser/password_manager.h"
@@ skipping 157 matching lines @@
 
   // The normalized URL of the web page.
   rootDict.SetString("origin", formData.origin.spec());
 
   // The normalized URL from the "action" attribute of the <form> tag.
   rootDict.SetString("action", formData.action.spec());
 
   // Input elements in the form. The list does not necessarily contain
   // all elements from the form, but all elements listed here are required
   // to identify the right form to fill.
-  auto fieldList = make_scoped_ptr(new base::ListValue());
+  auto fieldList = base::WrapUnique(new base::ListValue());
 
-  auto usernameField = make_scoped_ptr(new base::DictionaryValue());
+  auto usernameField = base::WrapUnique(new base::DictionaryValue());
   usernameField->SetString("name", formData.username_field.name);
   usernameField->SetString("value", formData.username_field.value);
   fieldList->Append(usernameField.release());
 
-  auto passwordField = make_scoped_ptr(new base::DictionaryValue());
+  auto passwordField = base::WrapUnique(new base::DictionaryValue());
   passwordField->SetString("name", formData.password_field.name);
   passwordField->SetString("value", formData.password_field.value);
   fieldList->Append(passwordField.release());
 
   rootDict.Set("fields", fieldList.release());
 
   std::string jsonString;
   base::JSONWriter::Write(rootDict, &jsonString);
   return base::SysUTF8ToNSString(jsonString);
 }
 
 // Returns true if the trust level for the current page URL of |web_state| is
 // kAbsolute. If |page_url| is not null, fills it with the current page URL.
 bool GetPageURLAndCheckTrustLevel(web::WebState* web_state, GURL* page_url) {
   auto trustLevel = web::URLVerificationTrustLevel::kNone;
   GURL dummy;
   if (!page_url)
     page_url = &dummy;
   *page_url = web_state->GetCurrentURL(&trustLevel);
   return trustLevel == web::URLVerificationTrustLevel::kAbsolute;
 }
 
 }  // namespace
 
 @implementation PasswordController {
-  scoped_ptr<PasswordManager> passwordManager_;
-  scoped_ptr<PasswordGenerationManager> passwordGenerationManager_;
-  scoped_ptr<PasswordManagerClient> passwordManagerClient_;
-  scoped_ptr<PasswordManagerDriver> passwordManagerDriver_;
+  std::unique_ptr<PasswordManager> passwordManager_;
+  std::unique_ptr<PasswordGenerationManager> passwordGenerationManager_;
+  std::unique_ptr<PasswordManagerClient> passwordManagerClient_;
+  std::unique_ptr<PasswordManagerDriver> passwordManagerDriver_;
   base::scoped_nsobject<PasswordGenerationAgent> passwordGenerationAgent_;
 
   JsPasswordManager* passwordJsManager_;  // weak
 
   // The pending form data.
-  scoped_ptr<autofill::PasswordFormFillData> formData_;
+  std::unique_ptr<autofill::PasswordFormFillData> formData_;
 
   // Bridge to observe WebState from Objective-C.
-  scoped_ptr<web::WebStateObserverBridge> webStateObserverBridge_;
+  std::unique_ptr<web::WebStateObserverBridge> webStateObserverBridge_;
 }
 
 - (instancetype)initWithWebState:(web::WebState*)webState
              passwordsUiDelegate:(id<PasswordsUiDelegate>)UIDelegate {
   self = [self initWithWebState:webState
             passwordsUiDelegate:UIDelegate
                          client:nullptr];
   return self;
 }
 
 - (instancetype)initWithWebState:(web::WebState*)webState
              passwordsUiDelegate:(id<PasswordsUiDelegate>)UIDelegate
-                          client:(scoped_ptr<PasswordManagerClient>)
+                          client:(std::unique_ptr<PasswordManagerClient>)
                                      passwordManagerClient {
   DCHECK(webState);
   self = [super init];
   if (self) {
     webStateObserverBridge_.reset(
         new web::WebStateObserverBridge(webState, self));
     if (passwordManagerClient)
       passwordManagerClient_ = std::move(passwordManagerClient);
     else
       passwordManagerClient_.reset(new IOSChromePasswordManagerClient(self));
@@ skipping 53 matching lines @@
                         password:(NSString*)password
                completionHandler:(void (^)(BOOL))completionHandler {
   [self findPasswordFormsWithCompletionHandler:^(
             const std::vector<autofill::PasswordForm>& forms) {
     for (const auto& form : forms) {
       autofill::PasswordFormFillData formData;
       autofill::PasswordFormMap matches;
       // Initialize |matches| to satisfy the expectation from
       // InitPasswordFormFillData() that the preferred match (3rd parameter)
       // should be one of the |matches|.
-      auto scoped_form = make_scoped_ptr(new autofill::PasswordForm(form));
+      auto scoped_form = base::WrapUnique(new autofill::PasswordForm(form));
       matches.insert(
           std::make_pair(form.username_value, std::move(scoped_form)));
       autofill::InitPasswordFormFillData(form, matches, &form, false, false,
                                          &formData);
       [self fillPasswordForm:formData
                 withUsername:base::SysNSStringToUTF16(username)
                     password:base::SysNSStringToUTF16(password)
            completionHandler:completionHandler];
     }
   }];
@@ skipping 82 matching lines @@
            fromFormsJSON:(NSString*)jsonString
                  pageURL:(const GURL&)pageURL {
   DCHECK(forms);
   if (![jsonString length]) {
     VLOG(1) << "Error in password controller javascript.";
     return;
   }
 
   int errorCode = 0;
   std::string errorMessage;
-  scoped_ptr<base::Value> jsonData(base::JSONReader::ReadAndReturnError(
+  std::unique_ptr<base::Value> jsonData(base::JSONReader::ReadAndReturnError(
       std::string([jsonString UTF8String]), false, &errorCode, &errorMessage));
   if (errorCode || !jsonData || !jsonData->IsType(base::Value::TYPE_LIST)) {
     VLOG(1) << "JSON parse error " << errorMessage
             << " JSON string: " << [jsonString UTF8String];
     return;
   }
 
   const base::ListValue* formDataList;
   if (!jsonData->GetAsList(&formDataList))
     return;
@@ skipping 43 matching lines @@
 - (BOOL)getPasswordForm:(autofill::PasswordForm*)form
    fromPasswordFormJSON:(NSString*)jsonString
                 pageURL:(const GURL&)pageURL {
   DCHECK(form);
   // There is no identifiable password form on the page.
   if ([jsonString isEqualToString:@"noPasswordsFound"])
     return NO;
 
   int errorCode = 0;
   std::string errorMessage;
-  scoped_ptr<const base::Value> jsonData(base::JSONReader::ReadAndReturnError(
-      std::string([jsonString UTF8String]), false, &errorCode, &errorMessage));
+  std::unique_ptr<const base::Value> jsonData(
+      base::JSONReader::ReadAndReturnError(std::string([jsonString UTF8String]),
+                                           false, &errorCode, &errorMessage));
 
   // If the the JSON string contains null, there is no identifiable password
   // form on the page.
   if (!errorCode && !jsonData) {
     return NO;
   }
 
   if (errorCode || !jsonData->IsType(base::Value::TYPE_DICTIONARY)) {
     VLOG(1) << "JSON parse error " << errorMessage
             << " JSON string: " << [jsonString UTF8String];
@@ skipping 226 matching lines @@
     }
     autofill::FormFieldData field;
     field.name = std::move(element);
     field.form_control_type = base::UTF16ToUTF8(type);
     form->form_data.fields.push_back(field);
   }
 
   return YES;
 }
 
-- (void)showSavePasswordInfoBar:(scoped_ptr<PasswordFormManager>)formToSave {
+- (void)showSavePasswordInfoBar:
+    (std::unique_ptr<PasswordFormManager>)formToSave {
   if (!webStateObserverBridge_ || !webStateObserverBridge_->web_state())
     return;
 
   bool isSmartLockBrandingEnabled = false;
   if (self.browserState) {
     sync_driver::SyncService* sync_service =
         IOSChromeProfileSyncServiceFactory::GetForBrowserState(
             self.browserState);
     isSmartLockBrandingEnabled =
         password_bubble_experiment::IsSmartLockBrandingSavePromptEnabled(
@@ skipping 54 matching lines @@
 
 - (PasswordManager*)passwordManager {
   return passwordManager_.get();
 }
 
 - (JsPasswordManager*)passwordJsManager {
   return passwordJsManager_;
 }
 
 @end