[ObjC ARC] Converts ios/chrome/browser/passwords:passwords to ARC.

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 <map>
 #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/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_form_fill_data.h"
 #include "components/browser_sync/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"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "components/password_manager/core/browser/password_manager_driver.h"
 #include "components/sync/driver/sync_service.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/experimental_flags.h"
 #include "ios/chrome/browser/infobars/infobar_manager_impl.h"
 #import "ios/chrome/browser/passwords/ios_chrome_save_password_infobar_delegate.h"
 #import "ios/chrome/browser/passwords/ios_chrome_update_password_infobar_delegate.h"
 #import "ios/chrome/browser/passwords/js_password_manager.h"
 #import "ios/chrome/browser/passwords/password_generation_agent.h"
 #include "ios/chrome/browser/sync/ios_chrome_profile_sync_service_factory.h"
 #import "ios/web/public/origin_util.h"
 #include "ios/web/public/url_scheme_util.h"
 #import "ios/web/public/web_state/js/crw_js_injection_receiver.h"
 #import "ios/web/public/web_state/web_state.h"
 #include "url/gurl.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using password_manager::PasswordFormManager;
 using password_manager::PasswordGenerationManager;
 using password_manager::PasswordManager;
 using password_manager::PasswordManagerClient;
 using password_manager::PasswordManagerDriver;
 
 namespace {
 // Types of password infobars to display.
 enum class PasswordInfoBarType { SAVE, UPDATE };
 }
 
 @interface PasswordController ()
 
 // This is set to YES as soon as the associated WebState is destroyed.
 @property(readonly) BOOL isWebStateDestroyed;
 
+// Accessor for property inside block.
+@property(readonly) PasswordManager* passwordManager;
+
 @end
 
 @interface PasswordController ()<FormSuggestionProvider>
 
 // Parses the |jsonString| which contatins the password forms found on a web
 // page to populate the |forms| vector.
 - (void)getPasswordForms:(std::vector<autofill::PasswordForm>*)forms
            fromFormsJSON:(NSString*)jsonString
                  pageURL:(const GURL&)pageURL;
 
@@ skipping 171 matching lines @@
   return trustLevel == web::URLVerificationTrustLevel::kAbsolute;
 }
 
 }  // namespace
 
 @implementation PasswordController {
   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_;
+  PasswordGenerationAgent* passwordGenerationAgent_;
 
   JsPasswordManager* passwordJsManager_;  // weak
   web::WebState* webState_;               // weak
 
   // The pending form data.
   std::unique_ptr<autofill::PasswordFormFillData> formData_;
 
   // Bridge to observe WebState from Objective-C.
   std::unique_ptr<web::WebStateObserverBridge> webStateObserverBridge_;
 }
@@ skipping 19 matching lines @@
     if (passwordManagerClient)
       passwordManagerClient_ = std::move(passwordManagerClient);
     else
       passwordManagerClient_.reset(new IOSChromePasswordManagerClient(self));
     passwordManager_.reset(new PasswordManager(passwordManagerClient_.get()));
     passwordManagerDriver_.reset(new IOSChromePasswordManagerDriver(self));
     if (experimental_flags::IsPasswordGenerationEnabled() &&
         !passwordManagerClient_->IsIncognito()) {
       passwordGenerationManager_.reset(new PasswordGenerationManager(
           passwordManagerClient_.get(), passwordManagerDriver_.get()));
-      passwordGenerationAgent_.reset([[PasswordGenerationAgent alloc]
+      passwordGenerationAgent_ = [[PasswordGenerationAgent alloc]
                initWithWebState:webState
                 passwordManager:passwordManager_.get()
           passwordManagerDriver:passwordManagerDriver_.get()
-            passwordsUiDelegate:UIDelegate]);
+            passwordsUiDelegate:UIDelegate];
     }
 
     passwordJsManager_ = base::mac::ObjCCastStrict<JsPasswordManager>(
         [webState->GetJSInjectionReceiver()
             instanceOfClass:[JsPasswordManager class]]);
     webStateObserverBridge_.reset(
         new web::WebStateObserverBridge(webState, self));
   }
   return self;
 }
 
 - (instancetype)init {
   NOTREACHED();
   return nil;
 }
 
 - (void)dealloc {
   [self detach];
-  [super dealloc];
 }
 
 - (ios::ChromeBrowserState*)browserState {
   return webState_ ? ios::ChromeBrowserState::FromBrowserState(
                          webState_->GetBrowserState())
                    : nullptr;
 }
 
 - (const GURL&)lastCommittedURL {
   if (!webStateObserverBridge_ || !webStateObserverBridge_->web_state())
     return GURL::EmptyGURL();
   return webStateObserverBridge_->web_state()->GetLastCommittedURL();
 }
 
 - (void)detach {
   webState_ = nullptr;
   webStateObserverBridge_.reset();
-  passwordGenerationAgent_.reset();
+  passwordGenerationAgent_ = nil;
   passwordGenerationManager_.reset();
   passwordManagerDriver_.reset();
   passwordManager_.reset();
   passwordManagerClient_.reset();
 }
 
 - (void)findAndFillPasswordForms:(NSString*)username
                         password:(NSString*)password
                completionHandler:(void (^)(BOOL))completionHandler {
   [self findPasswordFormsWithCompletionHandler:^(
@@ skipping 36 matching lines @@
   passwordManager_->DidNavigateMainFrame();
 
   if (!webState->ContentIsHTML()) {
     // If the current page is not HTML, it does not contain any HTML forms.
     [self
         didFinishPasswordFormExtraction:std::vector<autofill::PasswordForm>()];
   }
 
   // Read all password forms from the page and send them to the password
   // manager.
-  base::WeakNSObject<PasswordController> weakSelf(self);
+  __weak PasswordController* weakSelf = self;
   [self findPasswordFormsWithCompletionHandler:^(
             const std::vector<autofill::PasswordForm>& forms) {
     [weakSelf didFinishPasswordFormExtraction:forms];
   }];
 }
 
 - (void)webState:(web::WebState*)webState
     didSubmitDocumentWithFormNamed:(const std::string&)formName
                      userInitiated:(BOOL)userInitiated {
-  base::WeakNSObject<PasswordController> weakSelf(self);
+  __weak PasswordController* weakSelf = self;
   // This code is racing against the new page loading and will not get the
   // password form data if the page has changed. In most cases this code wins
   // the race.
   // TODO(crbug.com/418827): Fix this by passing in more data from the JS side.
   id completionHandler = ^(BOOL found, const autofill::PasswordForm& form) {
-    if (weakSelf && ![weakSelf isWebStateDestroyed]) {
-      weakSelf.get()->passwordManager_->OnPasswordFormSubmitted(
-          weakSelf.get()->passwordManagerDriver_.get(), form);
+    PasswordController* strongSelf = weakSelf;
+    if (strongSelf && ![strongSelf isWebStateDestroyed]) {
+      strongSelf.passwordManager->OnPasswordFormSubmitted(
+          strongSelf.passwordManagerDriver, form);
     }
   };
   [self extractSubmittedPasswordForm:formName
                    completionHandler:completionHandler];
 }
 
 - (void)webStateDestroyed:(web::WebState*)webState {
   isWebStateDestroyed_ = YES;
   [self detach];
 }
 
 - (void)findPasswordFormsWithCompletionHandler:
     (void (^)(const std::vector<autofill::PasswordForm>&))completionHandler {
   DCHECK(completionHandler);
 
   if (!webStateObserverBridge_ || !webStateObserverBridge_->web_state())
     return;
 
   GURL pageURL;
   if (!GetPageURLAndCheckTrustLevel(webStateObserverBridge_->web_state(),
                                     &pageURL)) {
     return;
   }
 
-  base::WeakNSObject<PasswordController> weakSelf(self);
+  __weak PasswordController* weakSelf = self;
   [passwordJsManager_ findPasswordFormsWithCompletionHandler:^(
                           NSString* jsonString) {
     std::vector<autofill::PasswordForm> forms;
     [weakSelf getPasswordForms:&forms fromFormsJSON:jsonString pageURL:pageURL];
     completionHandler(forms);
   }];
 }
 
 - (void)getPasswordForms:(std::vector<autofill::PasswordForm>*)forms
            fromFormsJSON:(NSString*)JSONNSString
@@ skipping 41 matching lines @@
   if (!webStateObserverBridge_ || !webStateObserverBridge_->web_state())
     return;
 
   GURL pageURL;
   if (!GetPageURLAndCheckTrustLevel(webStateObserverBridge_->web_state(),
                                     &pageURL)) {
     completionHandler(NO, autofill::PasswordForm());
     return;
   }
 
-  base::WeakNSObject<PasswordController> weakSelf(self);
+  __weak PasswordController* weakSelf = self;
   id extractSubmittedFormCompletionHandler = ^(NSString* jsonString) {
     autofill::PasswordForm form;
     BOOL found = [weakSelf getPasswordForm:&form
                       fromPasswordFormJSON:jsonString
                                    pageURL:pageURL];
     completionHandler(found, form);
   };
 
   [passwordJsManager_ extractForm:base::SysUTF8ToNSString(formName)
                 completionHandler:extractSubmittedFormCompletionHandler];
@@ skipping 310 matching lines @@
     return;
   }
 
   [self fillPasswordForm:*formData_
             withUsername:formData_->username_field.value
                 password:formData_->password_field.value
        completionHandler:completionHandler];
 }
 
 - (PasswordGenerationAgent*)passwordGenerationAgent {
-  return passwordGenerationAgent_.get();
+  return passwordGenerationAgent_;
 }
 
 - (PasswordGenerationManager*)passwordGenerationManager {
   return passwordGenerationManager_.get();
 }
 
 - (PasswordManagerClient*)passwordManagerClient {
   return passwordManagerClient_.get();
 }
 
@@ skipping 34 matching lines @@
       break;
 
     case PasswordInfoBarType::UPDATE:
       IOSChromeUpdatePasswordInfoBarDelegate::Create(
           isSmartLockBrandingEnabled, infoBarManager, std::move(form));
       break;
   }
 }
 
 @end