[ios] ARCMigrate ios/chrome/browser/tabs/tab.mm to ARC.

ios/chrome/browser/tabs/tab.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/tabs/tab.h"
 
 #import <CoreLocation/CoreLocation.h>
 #import <UIKit/UIKit.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/ios/block_types.h"
-#import "base/ios/weak_nsobject.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
-#include "base/mac/objc_property_releaser.h"
-#include "base/mac/scoped_nsobject.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string_split.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/favicon/core/favicon_driver_observer.h"
 #include "components/favicon/ios/web_favicon_driver.h"
@@ skipping 99 matching lines @@
 #import "net/base/mac/url_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/page_transition_types.h"
 #include "url/origin.h"
 
-using base::UserMetricsAction;
-using web::NavigationManagerImpl;
-using net::RequestTracker;
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
 
 NSString* const kTabUrlStartedLoadingNotificationForCrashReporting =
     @"kTabUrlStartedLoadingNotificationForCrashReporting";
 NSString* const kTabUrlMayStartLoadingNotificationForCrashReporting =
     @"kTabUrlMayStartLoadingNotificationForCrashReporting";
 NSString* const kTabIsShowingExportableNotificationForCrashReporting =
     @"kTabIsShowingExportableNotificationForCrashReporting";
 NSString* const kTabClosingCurrentDocumentNotificationForCrashReporting =
     @"kTabClosingCurrentDocumentNotificationForCrashReporting";
 
@@ skipping 37 matching lines @@
 
 // Returns true if |item| is the result of a HTTP redirect.
 // Returns false if |item| is nullptr;
 bool IsItemRedirectItem(web::NavigationItem* item) {
   if (!item)
     return false;
 
   return (ui::PageTransition::PAGE_TRANSITION_IS_REDIRECT_MASK &
           item->GetTransitionType()) == 0;
 }
+
+// TabHistoryContext is used by history to scope the lifetime of navigation
+// entry references to Tab.
+class TabHistoryContext : public history::Context {
+ public:
+  TabHistoryContext() {}
+  ~TabHistoryContext() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TabHistoryContext);
+};
 }  // namespace
 
 @interface Tab ()<CRWWebStateObserver,
                   CRWWebControllerObserver,
                   FindInPageControllerDelegate,
                   ReaderModeControllerDelegate> {
-  TabModel* parentTabModel_;               // weak
-  ios::ChromeBrowserState* browserState_;  // weak
+  __weak TabModel* parentTabModel_;
+  ios::ChromeBrowserState* browserState_;
 
-  base::scoped_nsobject<OpenInController> openInController_;
-  base::WeakNSProtocol<id<PassKitDialogProvider>> passKitDialogProvider_;
+  OpenInController* openInController_;
 
   // Whether or not this tab is currently being displayed.
   BOOL visible_;
 
   // Holds entries that need to be added to the history DB.  Prerender tabs do
   // not write navigation data to the history DB.  Instead, they cache history
   // data in this vector and add it to the DB when the prerender status is
   // removed (when the Tab is swapped in as a real Tab).
   std::vector<history::HistoryAddPageArgs> addPageVector_;
 
   // YES if this Tab is being prerendered.
   BOOL isPrerenderTab_;
 
   // YES if this Tab was initiated from a voice search.
   BOOL isVoiceSearchResultsTab_;
 
   // YES if the Tab needs to be reloaded after the app becomes active.
   BOOL requireReloadAfterBecomingActive_;
 
   // Last visited timestamp.
   double lastVisitedTimestamp_;
 
-  base::mac::ObjCPropertyReleaser propertyReleaser_Tab_;
-
-  id<TabDelegate> delegate_;  // weak
-  base::WeakNSProtocol<id<TabDialogDelegate>> dialogDelegate_;
-  base::WeakNSProtocol<id<SnapshotOverlayProvider>> snapshotOverlayProvider_;
-
-  // Delegate used for snapshotting geometry.
-  id<TabSnapshottingDelegate> tabSnapshottingDelegate_;  // weak
-
   // The Full Screen Controller responsible for hiding/showing the toolbar.
-  base::scoped_nsobject<FullScreenController> fullScreenController_;
-
-  // The delegate responsible for headers over the tab.
-  id<TabHeadersDelegate> tabHeadersDelegate_;  // weak
-
-  base::WeakNSProtocol<id<FullScreenControllerDelegate>>
-      fullScreenControllerDelegate_;
+  FullScreenController* fullScreenController_;
 
   // The Overscroll controller responsible for displaying the
   // overscrollActionsView above the toolbar.
-  base::scoped_nsobject<OverscrollActionsController>
-      overscrollActionsController_;
-  base::WeakNSProtocol<id<OverscrollActionsControllerDelegate>>
-      overscrollActionsControllerDelegate_;
-
-  base::scoped_nsobject<NSString> tabId_;
+  OverscrollActionsController* overscrollActionsController_;
 
   // Lightweight object dealing with various different UI behaviours when
   // opening a URL in an external application.
-  base::scoped_nsobject<ExternalAppLauncher> externalAppLauncher_;
+  ExternalAppLauncher* externalAppLauncher_;
 
   // Handles suggestions for form entry.
-  base::scoped_nsobject<FormSuggestionController> suggestionController_;
+  FormSuggestionController* suggestionController_;
 
   // Manages the input accessory view during form input.
-  base::scoped_nsobject<FormInputAccessoryViewController>
-      inputAccessoryViewController_;
-
-  // TODO(crbug.com/661665): move the WebContentsObservers into their own
-  // container.
-  // Handles saving and autofill of passwords.
-  base::scoped_nsobject<PasswordController> passwordController_;
+  FormInputAccessoryViewController* inputAccessoryViewController_;
 
   // Handles autofill.
-  base::scoped_nsobject<AutofillController> autofillController_;
+  AutofillController* autofillController_;
 
   // Handles caching and retrieving of snapshots.
-  base::scoped_nsobject<SnapshotManager> snapshotManager_;
+  SnapshotManager* snapshotManager_;
 
   // Handles retrieving, generating and updating snapshots of CRWWebController's
   // web page.
-  base::scoped_nsobject<WebControllerSnapshotHelper>
-      webControllerSnapshotHelper_;
+  WebControllerSnapshotHelper* webControllerSnapshotHelper_;
 
   // Handles support for window.print JavaScript calls.
   std::unique_ptr<PrintObserver> printObserver_;
 
   // AutoReloadBridge for this tab.
-  base::scoped_nsobject<AutoReloadBridge> autoReloadBridge_;
+  AutoReloadBridge* autoReloadBridge_;
 
   // WebStateImpl for this tab.
   web::WebStateImpl* webStateImpl_;
 
   // Allows Tab to conform CRWWebStateDelegate protocol.
   std::unique_ptr<web::WebStateObserverBridge> webStateObserver_;
 
   // Context used by history to scope the lifetime of navigation entry
   // references to Tab.
-  std::unique_ptr<TabHistoryContext> tabHistoryContext_;
-
-  // The controller for everything related to reader mode.
-  base::scoped_nsobject<ReaderModeController> readerModeController_;
+  TabHistoryContext tabHistoryContext_;
 
   // C++ bridge that receives notifications from the FaviconDriver.
   std::unique_ptr<FaviconDriverObserverBridge> faviconDriverObserverBridge_;
 
   // U2F call controller object.
-  base::scoped_nsobject<U2FController> U2FController_;
+  U2FController* U2FController_;
 
   // C++ observer used to trigger snapshots after the removal of InfoBars.
   std::unique_ptr<TabInfoBarObserver> tabInfoBarObserver_;
 }
 
 // Returns the tab's reader mode controller. May contain nil if the feature is
 // disabled.
 @property(nonatomic, readonly) ReaderModeController* readerModeController;
 
 // Returns a list of FormSuggestionProviders to be queried for suggestions
@@ skipping 25 matching lines @@
 // Called after the session history is replaced, useful for updating members
 // with new sessionID.
 - (void)didReplaceSessionHistory;
 
 // Called when the UIApplication's state becomes active.
 - (void)applicationDidBecomeActive;
 
 @end
 
 namespace {
-// TabHistoryContext is used by history to scope the lifetime of navigation
-// entry references to Tab.
-class TabHistoryContext : public history::Context {
- public:
-  TabHistoryContext() {}
-  ~TabHistoryContext() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TabHistoryContext);
-};
-
 class FaviconDriverObserverBridge : public favicon::FaviconDriverObserver {
  public:
   FaviconDriverObserverBridge(Tab* owner,
                               favicon::FaviconDriver* favicon_driver);
   ~FaviconDriverObserverBridge() override;
 
   // favicon::FaviconDriverObserver implementation.
   void OnFaviconUpdated(favicon::FaviconDriver* favicon_driver,
                         NotificationIconType notification_icon_type,
                         const GURL& icon_url,
                         bool icon_url_changed,
                         const gfx::Image& image) override;
 
  private:
-  Tab* owner_;  // Owns this instance.
+  __weak Tab* owner_;
   ScopedObserver<favicon::FaviconDriver, favicon::FaviconDriverObserver>
       scoped_observer_;
   DISALLOW_COPY_AND_ASSIGN(FaviconDriverObserverBridge);
 };
 
 FaviconDriverObserverBridge::FaviconDriverObserverBridge(
     Tab* owner,
     favicon::FaviconDriver* favicon_driver)
     : owner_(owner), scoped_observer_(this) {
   scoped_observer_.Add(favicon_driver);
@@ skipping 15 matching lines @@
  public:
   explicit TabInfoBarObserver(Tab* owner);
   ~TabInfoBarObserver() override;
   void SetShouldObserveInfoBarManager(bool should_observe);
   void OnInfoBarAdded(infobars::InfoBar* infobar) override;
   void OnInfoBarRemoved(infobars::InfoBar* infobar, bool animate) override;
   void OnInfoBarReplaced(infobars::InfoBar* old_infobar,
                          infobars::InfoBar* new_infobar) override;
 
  private:
-  Tab* owner_;  // Owns this instance;
+  __weak Tab* owner_;
   ScopedObserver<infobars::InfoBarManager, TabInfoBarObserver> scoped_observer_;
   DISALLOW_COPY_AND_ASSIGN(TabInfoBarObserver);
 };
 
 TabInfoBarObserver::TabInfoBarObserver(Tab* owner)
     : owner_(owner), scoped_observer_(this) {}
 
 TabInfoBarObserver::~TabInfoBarObserver() {}
 
 void TabInfoBarObserver::SetShouldObserveInfoBarManager(bool should_observe) {
@@ skipping 24 matching lines @@
                                            infobars::InfoBar* new_infobar) {
   // Update snapshots after the infobar has been replaced.
   [owner_ updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
 }
 
 }  // anonymous namespace
 
 @implementation Tab
 
 @synthesize browserState = browserState_;
+@synthesize tabId = tabId_;
 @synthesize useGreyImageCache = useGreyImageCache_;
 @synthesize isPrerenderTab = isPrerenderTab_;
 @synthesize isLinkLoadingPrerenderTab = isLinkLoadingPrerenderTab_;
 @synthesize isVoiceSearchResultsTab = isVoiceSearchResultsTab_;
+@synthesize passwordController = passwordController_;
+@synthesize overscrollActionsController = overscrollActionsController_;
+@synthesize readerModeController = readerModeController_;
+@synthesize overscrollActionsControllerDelegate =
+    overscrollActionsControllerDelegate_;
+@synthesize passKitDialogProvider = passKitDialogProvider_;
 @synthesize delegate = delegate_;
+@synthesize dialogDelegate = dialogDelegate_;
+@synthesize snapshotOverlayProvider = snapshotOverlayProvider_;
 @synthesize tabSnapshottingDelegate = tabSnapshottingDelegate_;
 @synthesize tabHeadersDelegate = tabHeadersDelegate_;
+@synthesize fullScreenControllerDelegate = fullScreenControllerDelegate_;
 
 - (instancetype)initWithWebState:(web::WebState*)webState {
   DCHECK(webState);
   self = [super init];
   if (self) {
-    propertyReleaser_Tab_.Init(self, [Tab class]);
-
     // TODO(crbug.com/620465): Tab should only use public API of WebState.
     // Remove this cast once this is the case.
     webStateImpl_ = static_cast<web::WebStateImpl*>(webState);
     browserState_ =
         ios::ChromeBrowserState::FromBrowserState(webState->GetBrowserState());
-
-    tabHistoryContext_ = base::MakeUnique<TabHistoryContext>();
     webStateObserver_ =
         base::MakeUnique<web::WebStateObserverBridge>(webState, self);
 
     [self updateLastVisitedTimestamp];
     [[self webController] addObserver:self];
     [[self webController] setDelegate:self];
 
-    snapshotManager_.reset([[SnapshotManager alloc] init]);
-    webControllerSnapshotHelper_.reset([[WebControllerSnapshotHelper alloc]
+    snapshotManager_ = [[SnapshotManager alloc] init];
+    webControllerSnapshotHelper_ = [[WebControllerSnapshotHelper alloc]
         initWithSnapshotManager:snapshotManager_
-                            tab:self]);
+                            tab:self];
 
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(applicationDidBecomeActive)
                name:UIApplicationDidBecomeActiveNotification
              object:nil];
   }
   return self;
 }
 
 - (void)attachTabHelpers {
-  tabInfoBarObserver_.reset(new TabInfoBarObserver(self));
+  tabInfoBarObserver_ = base::MakeUnique<TabInfoBarObserver>(self);
   tabInfoBarObserver_->SetShouldObserveInfoBarManager(true);
 
-  if (experimental_flags::IsAutoReloadEnabled()) {
-    autoReloadBridge_.reset([[AutoReloadBridge alloc] initWithTab:self]);
-  }
+  if (experimental_flags::IsAutoReloadEnabled())
+    autoReloadBridge_ = [[AutoReloadBridge alloc] initWithTab:self];
   printObserver_ = base::MakeUnique<PrintObserver>(self.webState);
 
-  base::scoped_nsprotocol<id<PasswordsUiDelegate>> passwordsUiDelegate(
-      [[PasswordsUiDelegateImpl alloc] init]);
-  passwordController_.reset([[PasswordController alloc]
-         initWithWebState:self.webState
-      passwordsUiDelegate:passwordsUiDelegate]);
+  id<PasswordsUiDelegate> passwordsUiDelegate =
+      [[PasswordsUiDelegateImpl alloc] init];
+  passwordController_ =
+      [[PasswordController alloc] initWithWebState:self.webState
+                               passwordsUiDelegate:passwordsUiDelegate];
   password_manager::PasswordGenerationManager* passwordGenerationManager =
       [passwordController_ passwordGenerationManager];
-  autofillController_.reset([[AutofillController alloc]
-           initWithBrowserState:browserState_
-      passwordGenerationManager:passwordGenerationManager
-                       webState:self.webState]);
-  suggestionController_.reset([[FormSuggestionController alloc]
+  autofillController_ =
+      [[AutofillController alloc] initWithBrowserState:browserState_
+                             passwordGenerationManager:passwordGenerationManager
+                                              webState:self.webState];
+  suggestionController_ = [[FormSuggestionController alloc]
       initWithWebState:self.webState
-             providers:[self suggestionProviders]]);
-  inputAccessoryViewController_.reset([[FormInputAccessoryViewController alloc]
+             providers:[self suggestionProviders]];
+  inputAccessoryViewController_ = [[FormInputAccessoryViewController alloc]
       initWithWebState:self.webState
-             providers:[self accessoryViewProviders]]);
+             providers:[self accessoryViewProviders]];
 
   [self setShouldObserveFaviconChanges:YES];
 
   // Create the ReaderModeController immediately so it can register for
   // WebState changes.
   if (experimental_flags::IsReaderModeEnabled()) {
-    readerModeController_.reset([[ReaderModeController alloc]
-        initWithWebState:self.webState
-                delegate:self]);
+    readerModeController_ =
+        [[ReaderModeController alloc] initWithWebState:self.webState
+                                              delegate:self];
   }
 }
 
 - (NSArray*)accessoryViewProviders {
   NSMutableArray* providers = [NSMutableArray array];
   id<FormInputAccessoryViewProvider> provider =
       [passwordController_ accessoryViewProvider];
   if (provider)
     [providers addObject:provider];
   [providers addObject:[suggestionController_ accessoryViewProvider]];
@@ skipping 31 matching lines @@
 }
 
 - (id<TabDialogDelegate>)dialogDelegate {
   return dialogDelegate_;
 }
 
 - (BOOL)loadFinished {
   return [self.webController loadPhase] == web::PAGE_LOADED;
 }
 
-- (void)setDialogDelegate:(id<TabDialogDelegate>)dialogDelegate {
-  dialogDelegate_.reset(dialogDelegate);
-}
-
 - (void)setIsVoiceSearchResultsTab:(BOOL)isVoiceSearchResultsTab {
   // There is intentionally no equality check in this setter, as we want the
   // notificaiton to be sent regardless of whether the value has changed.
   isVoiceSearchResultsTab_ = isVoiceSearchResultsTab;
   [parentTabModel_ notifyTabChanged:self];
 }
 
-- (PasswordController*)passwordController {
-  return passwordController_.get();
-}
-
 - (void)retrieveSnapshot:(void (^)(UIImage*))callback {
   [webControllerSnapshotHelper_
       retrieveSnapshotForWebController:self.webController
                              sessionID:self.tabId
                           withOverlays:[self snapshotOverlays]
                               callback:callback];
 }
 
 - (const GURL&)url {
   // See note in header; this method should be removed.
@@ skipping 32 matching lines @@
 
 - (NSString*)urlDisplayString {
   base::string16 urlText = url_formatter::FormatUrl(
       self.url, url_formatter::kFormatUrlOmitNothing, net::UnescapeRule::SPACES,
       nullptr, nullptr, nullptr);
   return base::SysUTF16ToNSString(urlText);
 }
 
 - (NSString*)tabId {
   if (tabId_)
-    return tabId_.get();
+    return tabId_;
 
   DCHECK(self.webState);
   web::SerializableUserDataManager* userDataManager =
       web::SerializableUserDataManager::FromWebState(self.webState);
   NSString* tabId = base::mac::ObjCCast<NSString>(
       userDataManager->GetValueForSerializationKey(kTabIDKey));
 
   if (!tabId || ![tabId length]) {
     tabId = [[NSUUID UUID] UUIDString];
     userDataManager->AddSerializableData(tabId, kTabIDKey);
   }
 
-  tabId_.reset([tabId copy]);
-  return tabId_.get();
+  tabId_ = [tabId copy];
+  return tabId_;
 }
 
 - (web::WebState*)webState {
   return webStateImpl_;
 }
 
 - (void)fetchFavicon {
   const GURL& url = self.url;
   if (!url.is_valid())
     return;
 
   favicon::FaviconDriver* faviconDriver =
       favicon::WebFaviconDriver::FromWebState(self.webState);
-  if (faviconDriver) {
+  if (faviconDriver)
     faviconDriver->FetchFavicon(url);
-  }
 }
 
 - (void)setFavicon:(const gfx::Image*)image {
   web::NavigationItem* item = [self navigationManager]->GetVisibleItem();
   if (!item)
     return;
   if (image) {
     item->GetFavicon().image = *image;
     item->GetFavicon().valid = true;
   }
   [parentTabModel_ notifyTabChanged:self];
 }
 
 - (UIImage*)favicon {
   DCHECK([self navigationManager]);
   web::NavigationItem* item = [self navigationManager]->GetVisibleItem();
   if (!item)
     return nil;
   const gfx::Image& image = item->GetFavicon().image;
   if (image.IsEmpty())
     return nil;
   return image.ToUIImage();
 }
 
 - (UIView*)view {
   // Record reload of previously-evicted tab.
-  if (![self.webController isViewAlive] && [parentTabModel_ tabUsageRecorder]) {
+  if (![self.webController isViewAlive] && [parentTabModel_ tabUsageRecorder])
     [parentTabModel_ tabUsageRecorder]->RecordPageLoadStart(self);
-  }
   return self.webState ? self.webState->GetView() : nil;
 }
 
 - (UIView*)viewForPrinting {
   return self.webController.viewForPrinting;
 }
 
 - (web::NavigationManager*)navigationManager {
   return self.webState ? self.webState->GetNavigationManager() : nullptr;
 }
@@ skipping 19 matching lines @@
 }
 
 - (void)didReplaceSessionHistory {
   // Replace fullScreenController_ with a new sessionID  when the navigation
   // manager changes.
   // TODO(crbug.com/661666): Consider just updating sessionID and not replacing
   // |fullScreenController_|.
   if (fullScreenController_) {
     [fullScreenController_ invalidate];
     [self.webController removeObserver:fullScreenController_];
-    fullScreenController_.reset([[FullScreenController alloc]
+    fullScreenController_ = [[FullScreenController alloc]
          initWithDelegate:fullScreenControllerDelegate_
         navigationManager:self.navigationManager
-                sessionID:self.tabId]);
+                sessionID:self.tabId];
     [self.webController addObserver:fullScreenController_];
     // If the content of the page was loaded without knowledge of the
     // toolbar position it will be misplaced under the toolbar instead of
     // right below. This happens e.g. in the case of preloading. This is to make
     // sure the content is moved to the right place.
     [fullScreenController_ moveContentBelowHeader];
   }
 }
 
 - (void)setIsLinkLoadingPrerenderTab:(BOOL)isLinkLoadingPrerenderTab {
@@ skipping 23 matching lines @@
   BOOL loadingFinished = self.webController.loadPhase == web::PAGE_LOADED;
   if (loadingFinished)
     [self updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
 
   [[OmniboxGeolocationController sharedInstance]
       finishPageLoadForTab:self
                loadSuccess:loadingFinished];
   [self countMainFrameLoad];
 }
 
-- (id<FullScreenControllerDelegate>)fullScreenControllerDelegate {
-  return fullScreenControllerDelegate_.get();
-}
-
 - (void)setFullScreenControllerDelegate:
     (id<FullScreenControllerDelegate>)fullScreenControllerDelegate {
-  if (fullScreenControllerDelegate == fullScreenControllerDelegate_) {
+  if (fullScreenControllerDelegate == fullScreenControllerDelegate_)
     return;
-  }
   // Lazily create a FullScreenController.
   // The check for fullScreenControllerDelegate is necessary to avoid recreating
   // a FullScreenController during teardown.
   if (!fullScreenController_ && fullScreenControllerDelegate) {
-    fullScreenController_.reset([[FullScreenController alloc]
+    fullScreenController_ = [[FullScreenController alloc]
          initWithDelegate:fullScreenControllerDelegate
         navigationManager:self.navigationManager
-                sessionID:self.tabId]);
+                sessionID:self.tabId];
     [self.webController addObserver:fullScreenController_];
     // If the content of the page was loaded without knowledge of the
     // toolbar position it will be misplaced under the toolbar instead of
     // right below. This happens e.g. in the case of preloading. This is to make
     // sure the content is moved to the right place.
     [fullScreenController_ moveContentBelowHeader];
   }
-  fullScreenControllerDelegate_.reset(fullScreenControllerDelegate);
-}
-
-- (OverscrollActionsController*)overscrollActionsController {
-  return overscrollActionsController_.get();
-}
-
-- (id<OverscrollActionsControllerDelegate>)overscrollActionsControllerDelegate {
-  return overscrollActionsControllerDelegate_.get();
+  fullScreenControllerDelegate_ = fullScreenControllerDelegate;
 }
 
 - (void)setOverscrollActionsControllerDelegate:
     (id<OverscrollActionsControllerDelegate>)
         overscrollActionsControllerDelegate {
   if (overscrollActionsControllerDelegate_ ==
-      overscrollActionsControllerDelegate)
+      overscrollActionsControllerDelegate) {
     return;
+  }
 
   // Lazily create a OverscrollActionsController.
   // The check for overscrollActionsControllerDelegate is necessary to avoid
   // recreating a OverscrollActionsController during teardown.
   if (!overscrollActionsController_) {
-    overscrollActionsController_.reset(
-        [[OverscrollActionsController alloc] init]);
+    overscrollActionsController_ = [[OverscrollActionsController alloc] init];
     [self.webController addObserver:overscrollActionsController_];
   }
   OverscrollStyle style = OverscrollStyle::REGULAR_PAGE_NON_INCOGNITO;
-  if (browserState_->IsOffTheRecord()) {
+  if (browserState_->IsOffTheRecord())
     style = OverscrollStyle::REGULAR_PAGE_INCOGNITO;
-  }
   [overscrollActionsController_ setStyle:style];
   [overscrollActionsController_
       setDelegate:overscrollActionsControllerDelegate];
-  overscrollActionsControllerDelegate_.reset(
-      overscrollActionsControllerDelegate);
+  overscrollActionsControllerDelegate_ = overscrollActionsControllerDelegate;
 }
 
 - (void)saveTitleToHistoryDB {
   // If incognito, don't update history.
   if (browserState_->IsOffTheRecord())
     return;
   // Don't update the history if current entry has no title.
   NSString* title = [self title];
   if (![title length] ||
-      [title isEqualToString:l10n_util::GetNSString(IDS_DEFAULT_TAB_TITLE)])
+      [title isEqualToString:l10n_util::GetNSString(IDS_DEFAULT_TAB_TITLE)]) {
     return;
+  }
 
   history::HistoryService* historyService =
       ios::HistoryServiceFactory::GetForBrowserState(
           browserState_, ServiceAccessType::IMPLICIT_ACCESS);
   DCHECK(historyService);
   historyService->SetPageTitle(self.url, base::SysNSStringToUTF16(title));
 }
 
 - (void)addCurrentEntryToHistoryDB {
   DCHECK([self navigationManager]->GetVisibleItem());
@@ skipping 45 matching lines @@
   }
 
   DCHECK(item->GetTimestamp().ToInternalValue() > 0);
   if ([self isPrerenderTab]) {
     // Clicks on content suggestions on the NTP should not contribute to the
     // Most Visited tiles in the NTP.
     const bool consider_for_ntp_most_visited =
         referrer.url != GURL(kChromeContentSuggestionsReferrer);
 
     history::HistoryAddPageArgs args(
-        url, item->GetTimestamp(), tabHistoryContext_.get(),
-        item->GetUniqueID(), referrer.url, redirects, item->GetTransitionType(),
+        url, item->GetTimestamp(), &tabHistoryContext_, item->GetUniqueID(),
+        referrer.url, redirects, item->GetTransitionType(),
         history::SOURCE_BROWSED, false, consider_for_ntp_most_visited);
     addPageVector_.push_back(args);
   } else {
-    historyService->AddPage(url, item->GetTimestamp(), tabHistoryContext_.get(),
+    historyService->AddPage(url, item->GetTimestamp(), &tabHistoryContext_,
                             item->GetUniqueID(), referrer.url, redirects,
                             item->GetTransitionType(), history::SOURCE_BROWSED,
                             false);
     [self saveTitleToHistoryDB];
   }
 }
 
 - (void)commitCachedEntriesToHistoryDB {
   // If OTR, don't update history.
   if (browserState_->IsOffTheRecord()) {
@@ skipping 27 matching lines @@
     }
   }
 
   ui::PageTransition transition = params.transition_type;
 
   // Record any explicit, non-redirect navigation as a clobber (as long as it's
   // in a real tab).
   if (!initialNavigation && !isPrerenderTab_ &&
       !PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_RELOAD) &&
       (transition & ui::PAGE_TRANSITION_IS_REDIRECT_MASK) == 0) {
-    base::RecordAction(UserMetricsAction("MobileTabClobbered"));
+    base::RecordAction(base::UserMetricsAction("MobileTabClobbered"));
   }
   if ([parentTabModel_ tabUsageRecorder])
     [parentTabModel_ tabUsageRecorder]->RecordPageLoadStart(self);
 
   // Reset |isVoiceSearchResultsTab| since a new page is being navigated to.
   self.isVoiceSearchResultsTab = NO;
 
   web::NavigationItem* navigationItem =
       [self navigationManager]->GetPendingItem();
 
   // TODO(crbug.com/676129): the pending item is not correctly set when the
   // page is reloading, use the last committed item if pending item is null.
   // Remove this once tracking bug is fixed.
   if (!navigationItem)
     navigationItem = [self navigationManager]->GetLastCommittedItem();
 
   [[OmniboxGeolocationController sharedInstance]
       addLocationToNavigationItem:navigationItem
                      browserState:browserState_];
 }
 
 - (void)loadSessionTab:(const sessions::SessionTab*)sessionTab {
   DCHECK(sessionTab);
   [self replaceHistoryWithNavigations:sessionTab->navigations
                          currentIndex:sessionTab->current_navigation_index];
 }
 
 - (void)webWillReload {
-  if ([parentTabModel_ tabUsageRecorder]) {
+  if ([parentTabModel_ tabUsageRecorder])
     [parentTabModel_ tabUsageRecorder]->RecordReload(self);
-  }
 }
 
 // Halt the tab, which amounts to halting its webController.
 - (void)terminateNetworkActivity {
   [self.webController terminateNetworkActivity];
 }
 
 - (void)webStateDestroyed:(web::WebState*)webState {
   DCHECK_EQ(webStateImpl_, webState);
   self.fullScreenControllerDelegate = nil;
   self.overscrollActionsControllerDelegate = nil;
   self.passKitDialogProvider = nil;
   self.snapshotOverlayProvider = nil;
 
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 
   [passwordController_ detach];
-  passwordController_.reset();
+  passwordController_ = nil;
   tabInfoBarObserver_.reset();
 
   faviconDriverObserverBridge_.reset();
   [openInController_ detachFromWebController];
-  openInController_.reset();
+  openInController_ = nil;
   [autofillController_ detachFromWebState];
   [suggestionController_ detachFromWebState];
   if (fullScreenController_)
     [self.webController removeObserver:fullScreenController_];
   [fullScreenController_ invalidate];
-  fullScreenController_.reset();
+  fullScreenController_ = nil;
   if (overscrollActionsController_)
     [self.webController removeObserver:overscrollActionsController_];
   [overscrollActionsController_ invalidate];
-  overscrollActionsController_.reset();
+  overscrollActionsController_ = nil;
   [readerModeController_ detachFromWebState];
-  readerModeController_.reset();
+  readerModeController_ = nil;
 
   // Invalidate any snapshot stored for this session.
   DCHECK(self.tabId);
   [snapshotManager_ removeImageWithSessionID:self.tabId];
 
   // Cancel any queued dialogs.
   [self.dialogDelegate cancelDialogForTab:self];
 
   webStateObserver_.reset();
   webStateImpl_ = nullptr;
 }
 
 - (void)dismissModals {
   [openInController_ disable];
   [self.webController dismissModals];
 }
 
 - (void)setShouldObserveInfoBarManager:(BOOL)shouldObserveInfoBarManager {
   tabInfoBarObserver_->SetShouldObserveInfoBarManager(
       shouldObserveInfoBarManager);
 }
 
 - (void)setShouldObserveFaviconChanges:(BOOL)shouldObserveFaviconChanges {
   if (shouldObserveFaviconChanges) {
     favicon::FaviconDriver* faviconDriver =
         favicon::WebFaviconDriver::FromWebState(self.webState);
     // Some MockWebContents used in tests do not support the FaviconDriver.
     if (faviconDriver) {
-      faviconDriverObserverBridge_.reset(
-          new FaviconDriverObserverBridge(self, faviconDriver));
+      faviconDriverObserverBridge_ =
+          base::MakeUnique<FaviconDriverObserverBridge>(self, faviconDriver);
     }
   } else {
     faviconDriverObserverBridge_.reset();
   }
 }
 
 - (void)goBack {
   if (self.navigationManager) {
     DCHECK(self.navigationManager->CanGoBack());
-    base::RecordAction(UserMetricsAction("Back"));
+    base::RecordAction(base::UserMetricsAction("Back"));
     self.navigationManager->GoBack();
   }
 }
 
 - (void)goForward {
   if (self.navigationManager) {
     DCHECK(self.navigationManager->CanGoForward());
-    base::RecordAction(UserMetricsAction("Forward"));
+    base::RecordAction(base::UserMetricsAction("Forward"));
     self.navigationManager->GoForward();
   }
 }
 
 - (BOOL)canGoBack {
   return self.navigationManager && self.navigationManager->CanGoBack();
 }
 
 - (BOOL)canGoForward {
   return self.navigationManager && self.navigationManager->CanGoForward();
 }
 
 - (void)goToItem:(const web::NavigationItem*)item {
   DCHECK(item);
 
   if (self.navigationManager) {
     CRWSessionController* sessionController =
         [self navigationManagerImpl]->GetSessionController();
     NSInteger itemIndex = [sessionController indexOfItem:item];
     DCHECK_NE(itemIndex, NSNotFound);
     self.navigationManager->GoToIndex(itemIndex);
   }
 }
 
 - (BOOL)openExternalURL:(const GURL&)url
               sourceURL:(const GURL&)sourceURL
             linkClicked:(BOOL)linkClicked {
-  if (!externalAppLauncher_.get())
-    externalAppLauncher_.reset([[ExternalAppLauncher alloc] init]);
-
-  // This method may release CRWWebController which may cause a crash
-  // (crbug.com/393949).
-  [[self.webController retain] autorelease];
+  if (!externalAppLauncher_)
+    externalAppLauncher_ = [[ExternalAppLauncher alloc] init];
 
   // Make a local url copy for possible modification.
   GURL finalURL = url;
 
   // Check if it's a direct FIDO U2F x-callback call. If so, do not open it, to
   // prevent pages from spoofing requests with different origins.
-  if (finalURL.SchemeIs("u2f-x-callback")) {
+  if (finalURL.SchemeIs("u2f-x-callback"))
     return NO;
-  }
 
   // Check if it's a FIDO U2F call.
   if (finalURL.SchemeIs("u2f")) {
     // Create U2FController object lazily.
-    if (!U2FController_) {
-      U2FController_.reset([[U2FController alloc] init]);
-    }
+    if (!U2FController_)
+      U2FController_ = [[U2FController alloc] init];
 
     DCHECK([self navigationManager]);
     GURL origin =
         [self navigationManager]->GetLastCommittedItem()->GetURL().GetOrigin();
 
     // Compose u2f-x-callback URL and update urlToOpen.
     finalURL = [U2FController_ XCallbackFromRequestURL:finalURL
                                              originURL:origin
                                                 tabURL:self.url
                                                  tabID:self.tabId];
 
-    if (!finalURL.is_valid()) {
+    if (!finalURL.is_valid())
       return NO;
-    }
   }
 
   if ([externalAppLauncher_ openURL:finalURL linkClicked:linkClicked]) {
     // Clears pending navigation history after successfully launching the
     // external app.
     DCHECK([self navigationManager]);
     [self navigationManager]->DiscardNonCommittedItems();
     // Ensure the UI reflects the current entry, not the just-discarded pending
     // entry.
     [parentTabModel_ notifyTabChanged:self];
 
     if (sourceURL.is_valid()) {
       ReadingListModel* model =
           ReadingListModelFactory::GetForBrowserState(browserState_);
-      if (model && model->loaded()) {
+      if (model && model->loaded())
         model->SetReadStatus(sourceURL, true);
-      }
     }
 
     return YES;
   }
   return NO;
 }
 
 - (void)webState:(web::WebState*)webState
     didFinishNavigation:(web::NavigationContext*)navigation {
   if (navigation->IsSameDocument()) {
+    // Fetch the favicon for the new URL.
     auto* faviconDriver = favicon::WebFaviconDriver::FromWebState(webState);
-    if (faviconDriver) {
-      // Fetch the favicon for the new URL.
+    if (faviconDriver)
       faviconDriver->FetchFavicon(navigation->GetUrl());
-    }
   }
 
   if (!navigation->IsErrorPage()) {
     [self addCurrentEntryToHistoryDB];
     [self countMainFrameLoad];
   }
 
   [parentTabModel_ notifyTabChanged:self];
 }
 
@@ skipping 10 matching lines @@
       break;
     case UIInterfaceOrientationUnknown:
       // TODO(crbug.com/228832): Convert from a boolean histogram to an
       // enumerated histogram and log this case as well.
       break;
   }
 }
 
 - (OpenInController*)openInController {
   if (!openInController_) {
-    openInController_.reset([[OpenInController alloc]
+    openInController_ = [[OpenInController alloc]
         initWithRequestContext:browserState_->GetRequestContext()
-                 webController:self.webController]);
+                 webController:self.webController];
   }
-  return openInController_.get();
+  return openInController_;
 }
 
 - (id<CRWNativeContent>)controllerForUnhandledContentAtURL:(const GURL&)url {
   // Shows download manager UI for unhandled content.
   DownloadManagerController* downloadController =
-      [[[DownloadManagerController alloc] initWithWebState:self.webState
-                                               downloadURL:url] autorelease];
+      [[DownloadManagerController alloc] initWithWebState:self.webState
+                                              downloadURL:url];
   [downloadController start];
   return downloadController;
 }
 
 - (void)handleExportableFile:(net::HttpResponseHeaders*)headers {
   // Only "application/pdf" is supported for now.
   if (self.webState->GetContentsMimeType() != "application/pdf")
     return;
 
   [[NSNotificationCenter defaultCenter]
@@ skipping 12 matching lines @@
                                 "",                 // referrer-charset
                                 "",                 // suggested-name
                                 "application/pdf",  // mime-type
                                 defaultFilename);
   [[self openInController]
       enableWithDocumentURL:self.url
           suggestedFilename:base::SysUTF16ToNSString(filename)];
 }
 
 - (void)countMainFrameLoad {
-  if ([self isPrerenderTab] || [self url].SchemeIs(kChromeUIScheme)) {
+  if ([self isPrerenderTab] || [self url].SchemeIs(kChromeUIScheme))
     return;
-  }
-  base::RecordAction(UserMetricsAction("MobilePageLoaded"));
+  base::RecordAction(base::UserMetricsAction("MobilePageLoaded"));
 }
 
 - (void)applicationDidBecomeActive {
-  if (requireReloadAfterBecomingActive_) {
-    if (visible_) {
-      self.navigationManager->Reload(web::ReloadType::NORMAL,
-                                     false /* check_for_repost */);
-    } else {
-      [self.webController requirePageReload];
-    }
-    requireReloadAfterBecomingActive_ = NO;
+  if (!requireReloadAfterBecomingActive_)
+    return;
+  if (visible_) {
+    self.navigationManager->Reload(web::ReloadType::NORMAL,
+                                   false /* check_for_repost */);
+  } else {
+    [self.webController requirePageReload];
   }
+  requireReloadAfterBecomingActive_ = NO;
 }
 
 #pragma mark -
 #pragma mark FindInPageControllerDelegate
 
 - (void)willAdjustScrollPosition {
   // Skip the next attempt to correct the scroll offset for the toolbar height.
   // Used when programatically scrolling down the y offset.
   [fullScreenController_ shouldSkipNextScrollOffsetForHeader];
 }
 
 #pragma mark -
 #pragma mark FullScreen
 
 - (void)updateFullscreenWithToolbarVisible:(BOOL)visible {
   [fullScreenController_ moveHeaderToRestingPosition:visible];
 }
 
 #pragma mark -
 #pragma mark Reader mode
 
 - (UIView*)superviewForReaderModePanel {
   return self.view;
 }
 
-- (ReaderModeController*)readerModeController {
-  return readerModeController_.get();
-}
-
 - (BOOL)canSwitchToReaderMode {
   // Only if the page is loaded and the page passes suitability checks.
   ReaderModeController* controller = self.readerModeController;
   return controller && controller.checker->CanSwitchToReaderMode();
 }
 
 - (void)switchToReaderMode {
   DCHECK(self.view);
   [self.readerModeController switchToReaderMode];
 }
@@ skipping 57 matching lines @@
       params.user_agent_override_option =
           web::NavigationManager::UserAgentOverrideOption::MOBILE;
       break;
     case web::UserAgentType::NONE:
       NOTREACHED();
   }
 
   navigationManager->LoadURLWithParams(params);
 }
 
-- (id<SnapshotOverlayProvider>)snapshotOverlayProvider {
-  return snapshotOverlayProvider_.get();
-}
-
-- (void)setSnapshotOverlayProvider:
-    (id<SnapshotOverlayProvider>)snapshotOverlayProvider {
-  snapshotOverlayProvider_.reset(snapshotOverlayProvider);
-}
-
 - (void)evaluateU2FResultFromURL:(const GURL&)URL {
   DCHECK(U2FController_);
   [U2FController_ evaluateU2FResultFromU2FURL:URL webState:self.webState];
 }
 
 #pragma mark - CRWWebControllerObserver protocol methods.
 
 - (void)webControllerWillClose:(CRWWebController*)webController {
   DCHECK_EQ(webController, [self webController]);
   [[self webController] removeObserver:self];
@@ skipping 20 matching lines @@
   BOOL isUserNavigationEvent =
       (transition & ui::PAGE_TRANSITION_IS_REDIRECT_MASK) == 0;
   // Check for link-follow clobbers. These are changes where there is no
   // pending entry (since that means the change wasn't caused by this class),
   // and where the URL changes (to avoid counting page resurrection).
   // TODO(crbug.com/546401): Consider moving this into NavigationManager, or
   // into a NavigationManager observer callback, so it doesn't need to be
   // checked in several places.
   if (isUserNavigationEvent && !isPrerenderTab_ &&
       ![self navigationManager]->GetPendingItem() && url != self.url) {
-    base::RecordAction(UserMetricsAction("MobileTabClobbered"));
+    base::RecordAction(base::UserMetricsAction("MobileTabClobbered"));
     if ([parentTabModel_ tabUsageRecorder])
       [parentTabModel_ tabUsageRecorder]->RecordPageLoadStart(self);
   }
   if (![self navigationManager]->GetPendingItem()) {
     // Reset |isVoiceSearchResultsTab| since a new page is being navigated to.
     self.isVoiceSearchResultsTab = NO;
   }
 }
 
 - (void)webState:(web::WebState*)webState
@@ skipping 18 matching lines @@
   [autoReloadBridge_ loadStartedForURL:lastCommittedURL];
 
   if (parentTabModel_) {
     [[NSNotificationCenter defaultCenter]
         postNotificationName:kTabModelTabWillStartLoadingNotification
                       object:parentTabModel_
                     userInfo:@{kTabModelTabKey : self}];
   }
   favicon::FaviconDriver* faviconDriver =
       favicon::WebFaviconDriver::FromWebState(webState);
-  if (faviconDriver) {
+  if (faviconDriver)
     faviconDriver->FetchFavicon(lastCommittedURL);
-  }
   [parentTabModel_ notifyTabChanged:self];
   if (parentTabModel_) {
     [[NSNotificationCenter defaultCenter]
         postNotificationName:kTabModelTabDidStartLoadingNotification
                       object:parentTabModel_
                     userInfo:@{kTabModelTabKey : self}];
   }
 
   web::NavigationItem* previousItem = nullptr;
   if (details.previous_item_index >= 0) {
@@ skipping 32 matching lines @@
       [self navigationManager]->GetLastCommittedItem();
   if (lastCommittedItem) {
     wasPost = lastCommittedItem->HasPostData();
     lastCommittedURL = lastCommittedItem->GetVirtualURL();
   }
   if (loadSuccess)
     [autoReloadBridge_ loadFinishedForURL:lastCommittedURL wasPost:wasPost];
   else
     [autoReloadBridge_ loadFailedForURL:lastCommittedURL wasPost:wasPost];
   [webControllerSnapshotHelper_ setSnapshotCoalescingEnabled:YES];
-  if (!loadSuccess) {
+  if (!loadSuccess)
     [fullScreenController_ disableFullScreen];
-  }
   [self recordInterfaceOrientation];
   navigation_metrics::RecordMainFrameNavigation(
       lastCommittedURL, true, self.browserState->IsOffTheRecord());
 
   if (loadSuccess) {
     scoped_refptr<net::HttpResponseHeaders> headers =
         webStateImpl_->GetHttpResponseHeaders();
     [self handleExportableFile:headers.get()];
   }
 
   [parentTabModel_ notifyTabChanged:self];
 
   if (parentTabModel_) {
     if ([parentTabModel_ tabUsageRecorder])
       [parentTabModel_ tabUsageRecorder]->RecordPageLoadDone(self, loadSuccess);
     [[NSNotificationCenter defaultCenter]
         postNotificationName:kTabModelTabDidFinishLoadingNotification
                       object:parentTabModel_
                     userInfo:[NSDictionary
                                  dictionaryWithObjectsAndKeys:
                                      self, kTabModelTabKey,
                                      [NSNumber numberWithBool:loadSuccess],
                                      kTabModelPageLoadSuccess, nil]];
   }
   [[OmniboxGeolocationController sharedInstance]
       finishPageLoadForTab:self
                loadSuccess:loadSuccess];
 
-  if (loadSuccess) {
+  if (loadSuccess)
     [self updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
-  }
   [webControllerSnapshotHelper_ setSnapshotCoalescingEnabled:NO];
 }
 
 - (void)webState:(web::WebState*)webState
     didChangeLoadingProgress:(double)progress {
   // TODO(crbug.com/546406): It is probably possible to do something smarter,
   // but the fact that this is not always sent will have to be taken into
   // account.
   [parentTabModel_ notifyTabChanged:self];
 }
@@ skipping 58 matching lines @@
           linkClicked:(BOOL)linkClicked {
   // chrome:// URLs are only allowed if the mainDocumentURL is also a chrome://
   // URL.
   if (url.SchemeIs(kChromeUIScheme) &&
       !mainDocumentURL.SchemeIs(kChromeUIScheme)) {
     return NO;
   }
 
   // Always allow frame loads.
   BOOL isFrameLoad = (url != mainDocumentURL);
-  if (isFrameLoad) {
+  if (isFrameLoad)
     return YES;
-  }
 
   // TODO(crbug.com/546402): If this turns out to be useful, find a less hacky
   // hook point to send this from.
   NSString* urlString = base::SysUTF8ToNSString(url.spec());
   if ([urlString length]) {
     [[NSNotificationCenter defaultCenter]
         postNotificationName:kTabUrlMayStartLoadingNotificationForCrashReporting
                       object:self
                     userInfo:[NSDictionary dictionaryWithObject:urlString
                                                          forKey:kTabUrlKey]];
@@ skipping 108 matching lines @@
     }
     UMA_HISTOGRAM_ENUMERATION(
         kRendererTerminationStateHistogram, static_cast<int>(tab_state),
         static_cast<int>(
             RendererTerminationTabState::TERMINATION_TAB_STATE_COUNT));
     if ([parentTabModel_ tabUsageRecorder])
       [parentTabModel_ tabUsageRecorder]->RendererTerminated(self, visible_);
   }
 
   if (visible_) {
-    if (!applicationIsNotActive) {
+    if (!applicationIsNotActive)
       [fullScreenController_ disableFullScreen];
-    }
   } else {
     [self.webController requirePageReload];
   }
   // Returning to the app (after the renderer crashed in the background) and
   // having the page reload is much less confusing for the user.
   // Note: Given that the tab is visible, calling |requirePageReload| will not
   // work when the app becomes active because there is nothing to trigger
   // a view redisplay in that scenario.
   requireReloadAfterBecomingActive_ = visible_ && applicationIsNotActive;
   [self.dialogDelegate cancelDialogForTab:self];
@@ skipping 21 matching lines @@
   if (isPrerenderTab_) {
     [delegate_ discardPrerender];
     return;
   }
   if (self != [parentTabModel_ currentTab])
     return;
 
   signin_metrics::LogAccountReconcilorStateOnGaiaResponse(
       ios::AccountReconcilorFactory::GetForBrowserState(browserState_)
           ->GetState());
-  base::scoped_nsobject<GenericChromeCommand> command(
-      [[GenericChromeCommand alloc] initWithTag:IDC_SHOW_ACCOUNTS_SETTINGS]);
+  GenericChromeCommand* command =
+      [[GenericChromeCommand alloc] initWithTag:IDC_SHOW_ACCOUNTS_SETTINGS];
   [self.view chromeExecuteCommand:command];
 }
 
 - (void)onAddAccount {
   if (isPrerenderTab_) {
     [delegate_ discardPrerender];
     return;
   }
   if (self != [parentTabModel_ currentTab])
     return;
 
   signin_metrics::LogAccountReconcilorStateOnGaiaResponse(
       ios::AccountReconcilorFactory::GetForBrowserState(browserState_)
           ->GetState());
-  base::scoped_nsobject<GenericChromeCommand> command(
-      [[GenericChromeCommand alloc] initWithTag:IDC_SHOW_ADD_ACCOUNT]);
+  GenericChromeCommand* command =
+      [[GenericChromeCommand alloc] initWithTag:IDC_SHOW_ADD_ACCOUNT];
   [self.view chromeExecuteCommand:command];
 }
 
 - (void)onGoIncognito:(const GURL&)url {
   if (isPrerenderTab_) {
     [delegate_ discardPrerender];
     return;
   }
   if (self != [parentTabModel_ currentTab])
     return;
 
   // The user taps on go incognito from the mobile U-turn webpage (the web page
   // that displays all users accounts available in the content area). As the
   // user chooses to go to incognito, the mobile U-turn page is no longer
   // neeeded. The current solution is to go back in history. This has the
   // advantage of keeping the current browsing session and give a good user
   // experience when the user comes back from incognito.
   [self goBack];
 
   if (url.is_valid()) {
-    base::scoped_nsobject<OpenUrlCommand> command([[OpenUrlCommand alloc]
+    OpenUrlCommand* command = [[OpenUrlCommand alloc]
          initWithURL:url
             referrer:web::Referrer()  // Strip referrer when switching modes.
          inIncognito:YES
         inBackground:NO
-            appendTo:kLastTab]);
+            appendTo:kLastTab];
     [self.view chromeExecuteCommand:command];
   } else {
-    base::scoped_nsobject<GenericChromeCommand> chromeCommand(
-        [[GenericChromeCommand alloc] initWithTag:IDC_NEW_INCOGNITO_TAB]);
-    [self.view chromeExecuteCommand:chromeCommand];
+    GenericChromeCommand* command =
+        [[GenericChromeCommand alloc] initWithTag:IDC_NEW_INCOGNITO_TAB];
+    [self.view chromeExecuteCommand:command];
   }
 }
 
 - (NativeAppNavigationController*)nativeAppNavigationController {
   // TODO(crbug.com/711511): This call should eventually be eliminated.
   return nil;
 }
 
-- (id<PassKitDialogProvider>)passKitDialogProvider {
-  return passKitDialogProvider_.get();
-}
-
-- (void)setPassKitDialogProvider:(id<PassKitDialogProvider>)provider {
-  passKitDialogProvider_.reset(provider);
-}
-
 - (void)wasShown {
   visible_ = YES;
   [self updateFullscreenWithToolbarVisible:YES];
   [self.webController wasShown];
   [inputAccessoryViewController_ wasShown];
 }
 
 - (void)wasHidden {
   visible_ = NO;
   [self updateFullscreenWithToolbarVisible:YES];
   [self.webController wasHidden];
   [inputAccessoryViewController_ wasHidden];
 }
 
 #pragma mark - SadTabTabHelperDelegate
 
 - (BOOL)isTabVisibleForTabHelper:(SadTabTabHelper*)tabHelper {
   UIApplicationState state = UIApplication.sharedApplication.applicationState;
   return visible_ && !IsApplicationStateNotActive(state);
 }
 
 @end
 
 #pragma mark - TestingSupport
 
 @implementation Tab (TestingSupport)
 
 - (void)replaceExternalAppLauncher:(id)externalAppLauncher {
-  externalAppLauncher_.reset([externalAppLauncher retain]);
+  externalAppLauncher_ = externalAppLauncher;
 }
 
 - (TabModel*)parentTabModel {
   return parentTabModel_;
 }
 
 - (FormInputAccessoryViewController*)inputAccessoryViewController {
-  return inputAccessoryViewController_.get();
+  return inputAccessoryViewController_;
 }
 
 @end