Update chrome/ to use WeakPtr<T>::get() instead of implicit "operator T*"

chrome/browser/automation/automation_provider_observers.cc

 // Copyright (c) 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.
 
 #include "chrome/browser/automation/automation_provider_observers.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 185 matching lines @@
     }
     items->Append(item);
   }
   DictionaryValue* return_value = new DictionaryValue;
   return_value->Set("tabs", items);
   return return_value;
 }
 
 void InitialLoadObserver::ConditionMet() {
   registrar_.RemoveAll();
-  if (automation_)
+  if (automation_.get())
     automation_->OnInitialTabLoadsComplete();
 }
 
 NewTabUILoadObserver::NewTabUILoadObserver(AutomationProvider* automation,
                                            Profile* profile)
     : automation_(automation->AsWeakPtr()) {
   registrar_.Add(this, chrome::NOTIFICATION_INITIAL_NEW_TAB_UI_LOAD,
                  content::Source<Profile>(profile));
 }
 
 NewTabUILoadObserver::~NewTabUILoadObserver() {
 }
 
 void NewTabUILoadObserver::Observe(int type,
                                    const content::NotificationSource& source,
                                    const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_INITIAL_NEW_TAB_UI_LOAD) {
     content::Details<int> load_time(details);
-    if (automation_) {
+    if (automation_.get()) {
       automation_->Send(
           new AutomationMsg_InitialNewTabUILoadComplete(*load_time.ptr()));
     }
   } else {
     NOTREACHED();
   }
 }
 
 NavigationControllerRestoredObserver::NavigationControllerRestoredObserver(
     AutomationProvider* automation,
@@ skipping 21 matching lines @@
     SendDone();
   }
 }
 
 bool NavigationControllerRestoredObserver::FinishedRestoring() {
   return (!controller_->NeedsReload() && !controller_->GetPendingEntry() &&
           !controller_->GetWebContents()->IsLoading());
 }
 
 void NavigationControllerRestoredObserver::SendDone() {
-  if (automation_) {
-    AutomationJSONReply(automation_, reply_message_.release())
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendSuccess(NULL);
   }
   delete this;
 }
 
 NavigationNotificationObserver::NavigationNotificationObserver(
     NavigationController* controller,
     AutomationProvider* automation,
     IPC::Message* reply_message,
     int number_of_navigations,
@@ skipping 23 matching lines @@
   if (include_current_navigation && controller->GetWebContents()->IsLoading())
     navigation_started_ = true;
 }
 
 NavigationNotificationObserver::~NavigationNotificationObserver() {
 }
 
 void NavigationNotificationObserver::Observe(
     int type, const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   // We listen for 2 events to determine when the navigation started because:
   // - when this is used by the WaitForNavigation method, we might be invoked
   // afer the load has started (but not after the entry was committed, as
   // WaitForNavigation compares times of the last navigation).
   // - when this is used with a page requiring authentication, we will not get
   // a chrome::NAV_ENTRY_COMMITTED until after we authenticate, so
@@ skipping 18 matching lines @@
     ConditionMet(AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED);
   } else if (type == chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN) {
     ConditionMet(AUTOMATION_MSG_NAVIGATION_BLOCKED_BY_MODAL_DIALOG);
   } else {
     NOTREACHED();
   }
 }
 
 void NavigationNotificationObserver::ConditionMet(
     AutomationMsg_NavigationResponseValues navigation_result) {
-  if (automation_) {
+  if (automation_.get()) {
     if (use_json_interface_) {
       if (navigation_result == AUTOMATION_MSG_NAVIGATION_SUCCESS) {
         DictionaryValue dict;
         dict.SetInteger("result", navigation_result);
-        AutomationJSONReply(automation_, reply_message_.release()).SendSuccess(
-            &dict);
+        AutomationJSONReply(automation_.get(), reply_message_.release())
+            .SendSuccess(&dict);
       } else {
-        AutomationJSONReply(automation_, reply_message_.release()).SendError(
-            base::StringPrintf("Navigation failed with error code=%d.",
-                               navigation_result));
+        AutomationJSONReply(automation_.get(), reply_message_.release())
+            .SendError(base::StringPrintf(
+                 "Navigation failed with error code=%d.", navigation_result));
       }
     } else {
       IPC::ParamTraits<int>::Write(
           reply_message_.get(), navigation_result);
       automation_->Send(reply_message_.release());
     }
   }
 
   delete this;
 }
@@ skipping 33 matching lines @@
                                    automation),
       parent_(parent),
       reply_message_(reply_message),
       use_json_interface_(use_json_interface) {
 }
 
 TabAppendedNotificationObserver::~TabAppendedNotificationObserver() {}
 
 void TabAppendedNotificationObserver::ObserveTab(
     NavigationController* controller) {
-  if (!automation_ || !reply_message_.get())
+  if (!automation_.get() || !reply_message_.get())
     return;
 
   if (automation_->GetIndexForNavigationController(controller, parent_) ==
       TabStripModel::kNoTab) {
     // This tab notification doesn't belong to the parent_.
     return;
   }
 
-  new NavigationNotificationObserver(controller, automation_,
+  new NavigationNotificationObserver(controller,
+                                     automation_.get(),
                                      reply_message_.release(),
-                                     1, false, use_json_interface_);
+                                     1,
+                                     false,
+                                     use_json_interface_);
 }
 
 IPC::Message* TabAppendedNotificationObserver::ReleaseReply() {
   return reply_message_.release();
 }
 
 TabClosedNotificationObserver::TabClosedNotificationObserver(
     AutomationProvider* automation,
     bool wait_until_closed,
     IPC::Message* reply_message,
     bool use_json_interface)
     : TabStripNotificationObserver((wait_until_closed ?
           static_cast<int>(content::NOTIFICATION_WEB_CONTENTS_DESTROYED) :
           static_cast<int>(chrome::NOTIFICATION_TAB_CLOSING)), automation),
       reply_message_(reply_message),
       use_json_interface_(use_json_interface),
       for_browser_command_(false) {
 }
 
 TabClosedNotificationObserver::~TabClosedNotificationObserver() {}
 
 void TabClosedNotificationObserver::ObserveTab(
     NavigationController* controller) {
-  if (!automation_)
+  if (!automation_.get())
     return;
 
   if (use_json_interface_) {
-    AutomationJSONReply(automation_,
-                        reply_message_.release()).SendSuccess(NULL);
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   } else {
     if (for_browser_command_) {
       AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message_.get(),
                                                            true);
     } else {
       AutomationMsg_CloseTab::WriteReplyParams(reply_message_.get(), true);
     }
     automation_->Send(reply_message_.release());
   }
 }
@@ skipping 24 matching lines @@
                                            bool foreground) {
   CheckTabCount();
 }
 
 void TabCountChangeObserver::TabDetachedAt(WebContents* contents,
                                            int index) {
   CheckTabCount();
 }
 
 void TabCountChangeObserver::TabStripModelDeleted() {
-  if (automation_) {
+  if (automation_.get()) {
     AutomationMsg_WaitForTabCountToBecome::WriteReplyParams(
         reply_message_.get(), false);
     automation_->Send(reply_message_.release());
   }
 
   delete this;
 }
 
 void TabCountChangeObserver::CheckTabCount() {
   if (tab_strip_model_->count() != target_tab_count_)
     return;
 
-  if (automation_) {
+  if (automation_.get()) {
     AutomationMsg_WaitForTabCountToBecome::WriteReplyParams(
         reply_message_.get(), true);
     automation_->Send(reply_message_.release());
   }
 
   delete this;
 }
 
 bool DidExtensionViewsStopLoading(ExtensionProcessManager* manager) {
   ExtensionProcessManager::ViewSet all_views = manager->GetAllViews();
@@ skipping 19 matching lines @@
                  content::NotificationService::AllSources());
 }
 
 ExtensionUninstallObserver::~ExtensionUninstallObserver() {
 }
 
 void ExtensionUninstallObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_UNINSTALLED: {
       if (id_ == content::Details<extensions::Extension>(details).ptr()->id()) {
         scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
         return_value->SetBoolean("success", true);
-        AutomationJSONReply(automation_, reply_message_.release())
+        AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendSuccess(return_value.get());
         delete this;
         return;
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED: {
       const extensions::Extension* extension =
           content::Details<extensions::Extension>(details).ptr();
       if (id_ == extension->id()) {
         scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
         return_value->SetBoolean("success", false);
-        AutomationJSONReply(automation_, reply_message_.release())
+        AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendSuccess(return_value.get());
         delete this;
         return;
       }
       break;
     }
 
     default:
       NOTREACHED();
   }
@@ skipping 22 matching lines @@
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
                  content::NotificationService::AllSources());
 }
 
 void ExtensionReadyNotificationObserver::Observe(
     int type, const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   switch (type) {
     case content::NOTIFICATION_LOAD_STOP:
       // Only continue on with this method if our extension has been loaded
       // and all the extension views have stopped loading.
       if (!extension_ || !DidExtensionViewsStopLoading(manager_))
         return;
@@ skipping 19 matching lines @@
     }
     case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR:
     case chrome::NOTIFICATION_EXTENSION_LOAD_ERROR:
     case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
       break;
     default:
       NOTREACHED();
       break;
   }
 
-  AutomationJSONReply reply(automation_, reply_message_.release());
+  AutomationJSONReply reply(automation_.get(), reply_message_.release());
   if (extension_) {
     DictionaryValue dict;
     dict.SetString("id", extension_->id());
     reply.SendSuccess(&dict);
   } else {
     reply.SendError("Extension could not be installed");
   }
   delete this;
 }
 
@@ skipping 24 matching lines @@
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  content::NotificationService::AllSources());
 }
 
 ExtensionsUpdatedObserver::~ExtensionsUpdatedObserver() {
 }
 
 void ExtensionsUpdatedObserver::Observe(
     int type, const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   DCHECK(type == content::NOTIFICATION_LOAD_STOP);
   MaybeReply();
 }
 
 void ExtensionsUpdatedObserver::UpdateCheckFinished() {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   // Extension updater has completed updating all extensions.
   updater_finished_ = true;
   MaybeReply();
 }
 
 void ExtensionsUpdatedObserver::MaybeReply() {
   // Send the reply if (1) the extension updater has finished updating all
   // extensions; and (2) all extension views have stopped loading.
   if (updater_finished_ && DidExtensionViewsStopLoading(manager_)) {
-    AutomationJSONReply reply(automation_, reply_message_.release());
+    AutomationJSONReply reply(automation_.get(), reply_message_.release());
     reply.SendSuccess(NULL);
     delete this;
   }
 }
 
 BrowserOpenedNotificationObserver::BrowserOpenedNotificationObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message,
     bool use_json_interface)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       new_window_id_(extension_misc::kUnknownWindowId),
       use_json_interface_(use_json_interface),
       for_browser_command_(false) {
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 BrowserOpenedNotificationObserver::~BrowserOpenedNotificationObserver() {
 }
 
 void BrowserOpenedNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   if (type == chrome::NOTIFICATION_BROWSER_OPENED) {
     // Store the new browser ID and continue waiting for a new tab within it
     // to stop loading.
     new_window_id_ = ExtensionTabUtil::GetWindowId(
         content::Source<Browser>(source).ptr());
   } else {
     DCHECK_EQ(content::NOTIFICATION_LOAD_STOP, type);
     // Only send the result if the loaded tab is in the new window.
     NavigationController* controller =
         content::Source<NavigationController>(source).ptr();
     SessionTabHelper* session_tab_helper =
         SessionTabHelper::FromWebContents(controller->GetWebContents());
     int window_id = session_tab_helper ? session_tab_helper->window_id().id()
                                        : -1;
     if (window_id == new_window_id_) {
       if (use_json_interface_) {
-        AutomationJSONReply(automation_,
-                            reply_message_.release()).SendSuccess(NULL);
+        AutomationJSONReply(automation_.get(), reply_message_.release())
+            .SendSuccess(NULL);
       } else {
         if (for_browser_command_) {
           AutomationMsg_WindowExecuteCommand::WriteReplyParams(
               reply_message_.get(), true);
         }
         automation_->Send(reply_message_.release());
       }
       delete this;
       return;
     }
@@ skipping 18 matching lines @@
                  content::Source<Browser>(browser));
 }
 
 BrowserClosedNotificationObserver::~BrowserClosedNotificationObserver() {}
 
 void BrowserClosedNotificationObserver::Observe(
     int type, const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_BROWSER_CLOSED, type);
 
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   // The automation layer doesn't support non-native desktops.
   int browser_count = static_cast<int>(BrowserList::GetInstance(
                           chrome::HOST_DESKTOP_TYPE_NATIVE)->size());
   // We get the notification before the browser is removed from the BrowserList.
   bool app_closing = browser_count == 1;
 
   if (use_json_interface_) {
-    AutomationJSONReply(automation_,
-                        reply_message_.release()).SendSuccess(NULL);
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   } else {
     if (for_browser_command_) {
       AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message_.get(),
                                                            true);
     } else {
       AutomationMsg_CloseBrowser::WriteReplyParams(reply_message_.get(), true,
                                                    app_closing);
     }
     automation_->Send(reply_message_.release());
   }
@@ skipping 31 matching lines @@
   // The automation layer doesn't support non-native desktops.
   int current_count = static_cast<int>(BrowserList::GetInstance(
                           chrome::HOST_DESKTOP_TYPE_NATIVE)->size());
   if (type == chrome::NOTIFICATION_BROWSER_CLOSED) {
     // At the time of the notification the browser being closed is not removed
     // from the list. The real count is one less than the reported count.
     DCHECK_LT(0, current_count);
     current_count--;
   }
 
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   if (current_count == target_count_) {
     AutomationMsg_WaitForBrowserWindowCountToBecome::WriteReplyParams(
         reply_message_.get(), true);
     automation_->Send(reply_message_.release());
     delete this;
   }
@@ skipping 84 matching lines @@
       break;
     }
   }
   return result;
 }
 
 void ExecuteBrowserCommandObserver::Observe(
     int type, const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == notification_type_) {
-    if (automation_) {
+    if (automation_.get()) {
       if (use_json_interface_) {
-        AutomationJSONReply(automation_,
-                            reply_message_.release()).SendSuccess(NULL);
+        AutomationJSONReply(automation_.get(), reply_message_.release())
+            .SendSuccess(NULL);
       } else {
         AutomationMsg_WindowExecuteCommand::WriteReplyParams(
             reply_message_.get(), true);
         automation_->Send(reply_message_.release());
       }
     }
     delete this;
   } else {
     NOTREACHED();
   }
@@ skipping 52 matching lines @@
 
 void FindInPageNotificationObserver::Observe(
     int type, const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   content::Details<FindNotificationDetails> find_details(details);
   if (!(find_details->final_update() && reply_message_ != NULL)) {
     DVLOG(1) << "Ignoring, since we only care about the final message";
     return;
   }
 
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   // We get multiple responses and one of those will contain the ordinal.
   // This message comes to us before the final update is sent.
   if (find_details->request_id() == kFindInPageRequestId) {
     if (reply_with_json_) {
       scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
       return_value->SetInteger("match_count",
           find_details->number_of_matches());
       gfx::Rect rect = find_details->selection_rect();
       // If MatchCount is > 0, then rect should not be Empty.
       // We dont guard it here because we want to let the test
       // code catch this invalid case if needed.
       if (!rect.IsEmpty()) {
         return_value->SetInteger("match_left", rect.x());
         return_value->SetInteger("match_top", rect.y());
         return_value->SetInteger("match_right", rect.right());
         return_value->SetInteger("match_bottom", rect.bottom());
       }
-      AutomationJSONReply(automation_, reply_message_.release())
+      AutomationJSONReply(automation_.get(), reply_message_.release())
           .SendSuccess(return_value.get());
       delete this;
     } else {
       if (find_details->active_match_ordinal() > -1) {
         active_match_ordinal_ = find_details->active_match_ordinal();
         AutomationMsg_Find::WriteReplyParams(reply_message_.get(),
             active_match_ordinal_, find_details->number_of_matches());
         automation_->Send(reply_message_.release());
       }
     }
@@ skipping 45 matching lines @@
     : DomOperationObserver(0),
       automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       use_json_interface_(use_json_interface) {
 }
 
 DomOperationMessageSender::~DomOperationMessageSender() {}
 
 void DomOperationMessageSender::OnDomOperationCompleted(
     const std::string& json) {
-  if (automation_) {
+  if (automation_.get()) {
     if (use_json_interface_) {
       DictionaryValue dict;
       dict.SetString("result", json);
-      AutomationJSONReply(automation_, reply_message_.release())
+      AutomationJSONReply(automation_.get(), reply_message_.release())
           .SendSuccess(&dict);
     } else {
       AutomationMsg_DomOperation::WriteReplyParams(reply_message_.get(), json);
       automation_->Send(reply_message_.release());
     }
   }
   delete this;
 }
 
 void DomOperationMessageSender::OnModalDialogShown() {
-  if (automation_ && use_json_interface_) {
-    AutomationJSONReply(automation_, reply_message_.release())
+  if (automation_.get() && use_json_interface_) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendErrorCode(automation::kBlockedByModalDialog);
     delete this;
   }
 }
 
 void DomOperationMessageSender::OnJavascriptBlocked() {
-  if (automation_ && use_json_interface_) {
-    AutomationJSONReply(automation_, reply_message_.release())
+  if (automation_.get() && use_json_interface_) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendError("Javascript execution was blocked");
     delete this;
   }
 }
 
 MetricEventDurationObserver::MetricEventDurationObserver() {
   registrar_.Add(this, chrome::NOTIFICATION_METRIC_EVENT_DURATION,
                  content::NotificationService::AllSources());
 }
 
@@ skipping 48 matching lines @@
          type == chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED);
   CheckCount();
 }
 
 void InfoBarCountObserver::CheckCount() {
   InfoBarService* infobar_service =
       InfoBarService::FromWebContents(web_contents_);
   if (infobar_service->infobar_count() != target_count_)
     return;
 
-  if (automation_) {
+  if (automation_.get()) {
     AutomationMsg_WaitForInfoBarCount::WriteReplyParams(reply_message_.get(),
                                                         true);
     automation_->Send(reply_message_.release());
   }
   delete this;
 }
 
 AutomationProviderBookmarkModelObserver::
 AutomationProviderBookmarkModelObserver(
     AutomationProvider* provider,
@@ skipping 20 matching lines @@
 void AutomationProviderBookmarkModelObserver::BookmarkModelBeingDeleted(
     BookmarkModel* model) {
   ReplyAndDelete(false);
 }
 
 IPC::Message* AutomationProviderBookmarkModelObserver::ReleaseReply() {
   return reply_message_.release();
 }
 
 void AutomationProviderBookmarkModelObserver::ReplyAndDelete(bool success) {
-  if (automation_provider_) {
+  if (automation_provider_.get()) {
     if (use_json_interface_) {
-      AutomationJSONReply(automation_provider_,
-                          reply_message_.release()).SendSuccess(NULL);
+      AutomationJSONReply(automation_provider_.get(), reply_message_.release())
+          .SendSuccess(NULL);
     } else {
       AutomationMsg_WaitForBookmarkModelToLoad::WriteReplyParams(
           reply_message_.get(), success);
       automation_provider_->Send(reply_message_.release());
     }
   }
   delete this;
 }
 
 AutomationProviderDownloadUpdatedObserver::
@@ skipping 13 matching lines @@
 
 void AutomationProviderDownloadUpdatedObserver::OnDownloadUpdated(
     DownloadItem* download) {
   // If this observer is watching for open, only send the reply if the download
   // has been auto-opened.
   if (wait_for_open_ && !download->GetAutoOpened())
     return;
 
   download->RemoveObserver(this);
 
-  if (provider_) {
+  if (provider_.get()) {
     scoped_ptr<DictionaryValue> return_value(
         provider_->GetDictionaryFromDownloadItem(download, incognito_));
-    AutomationJSONReply(provider_, reply_message_.release()).SendSuccess(
-        return_value.get());
+    AutomationJSONReply(provider_.get(), reply_message_.release())
+        .SendSuccess(return_value.get());
   }
   delete this;
 }
 
 void AutomationProviderDownloadUpdatedObserver::OnDownloadOpened(
     DownloadItem* download) {
   download->RemoveObserver(this);
 
-  if (provider_) {
+  if (provider_.get()) {
     scoped_ptr<DictionaryValue> return_value(
         provider_->GetDictionaryFromDownloadItem(download, incognito_));
-    AutomationJSONReply(provider_, reply_message_.release()).SendSuccess(
-        return_value.get());
+    AutomationJSONReply(provider_.get(), reply_message_.release())
+        .SendSuccess(return_value.get());
   }
   delete this;
 }
 
 AutomationProviderDownloadModelChangedObserver::
 AutomationProviderDownloadModelChangedObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message,
     DownloadManager* download_manager)
     : provider_(provider->AsWeakPtr()),
       reply_message_(reply_message),
       notifier_(download_manager, this) {
 }
 
 AutomationProviderDownloadModelChangedObserver::
     ~AutomationProviderDownloadModelChangedObserver() {}
 
 void AutomationProviderDownloadModelChangedObserver::ModelChanged() {
-  if (provider_)
-    AutomationJSONReply(provider_, reply_message_.release()).SendSuccess(NULL);
+  if (provider_.get())
+    AutomationJSONReply(provider_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   delete this;
 }
 
 void AutomationProviderDownloadModelChangedObserver::OnDownloadCreated(
     DownloadManager* manager, DownloadItem* item) {
   ModelChanged();
 }
 
 void AutomationProviderDownloadModelChangedObserver::OnDownloadRemoved(
     DownloadManager* manager, DownloadItem* item) {
   ModelChanged();
 }
 
 AllDownloadsCompleteObserver::AllDownloadsCompleteObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message,
     DownloadManager* download_manager,
     ListValue* pre_download_ids)
     : provider_(provider->AsWeakPtr()),
       reply_message_(reply_message),
       download_manager_(download_manager) {
   for (ListValue::iterator it = pre_download_ids->begin();
        it != pre_download_ids->end(); ++it) {
     int val = 0;
     if ((*it)->GetAsInteger(&val)) {
       pre_download_ids_.insert(val);
     } else {
-      AutomationJSONReply(provider_, reply_message_.release())
+      AutomationJSONReply(provider_.get(), reply_message_.release())
           .SendError("Cannot convert ID of prior download to integer.");
       delete this;
       return;
     }
   }
   download_manager_->AddObserver(this);
   DownloadManager::DownloadVector all_items;
   download_manager->GetAllDownloads(&all_items);
   for (DownloadManager::DownloadVector::const_iterator
        it = all_items.begin(); it != all_items.end(); ++it) {
@@ skipping 38 matching lines @@
     pending_downloads_.erase(download);
     ReplyIfNecessary();
   }
 }
 
 void AllDownloadsCompleteObserver::ReplyIfNecessary() {
   if (!pending_downloads_.empty())
     return;
 
   download_manager_->RemoveObserver(this);
-  if (provider_)
-    AutomationJSONReply(provider_, reply_message_.release()).SendSuccess(NULL);
+  if (provider_.get())
+    AutomationJSONReply(provider_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   delete this;
 }
 
 AutomationProviderSearchEngineObserver::AutomationProviderSearchEngineObserver(
     AutomationProvider* provider,
     Profile* profile,
     IPC::Message* reply_message)
     : provider_(provider->AsWeakPtr()),
       profile_(profile),
       reply_message_(reply_message) {
 }
 
 AutomationProviderSearchEngineObserver::
     ~AutomationProviderSearchEngineObserver() {}
 
 void AutomationProviderSearchEngineObserver::OnTemplateURLServiceChanged() {
-  if (provider_) {
+  if (provider_.get()) {
     TemplateURLService* url_service =
         TemplateURLServiceFactory::GetForProfile(profile_);
     url_service->RemoveObserver(this);
-    AutomationJSONReply(provider_, reply_message_.release()).SendSuccess(NULL);
+    AutomationJSONReply(provider_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   }
   delete this;
 }
 
 AutomationProviderHistoryObserver::AutomationProviderHistoryObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message)
     : provider_(provider->AsWeakPtr()),
       reply_message_(reply_message) {
 }
 
 AutomationProviderHistoryObserver::~AutomationProviderHistoryObserver() {}
 
 void AutomationProviderHistoryObserver::HistoryQueryComplete(
     HistoryService::Handle request_handle,
     history::QueryResults* results) {
-  if (!provider_) {
+  if (!provider_.get()) {
     delete this;
     return;
   }
 
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   ListValue* history_list = new ListValue;
   for (size_t i = 0; i < results->size(); ++i) {
     DictionaryValue* page_value = new DictionaryValue;
     history::URLResult const &page = (*results)[i];
     page_value->SetString("title", page.title());
     page_value->SetString("url", page.url().spec());
     page_value->SetDouble("time",
                           static_cast<double>(page.visit_time().ToDoubleT()));
     page_value->SetString("snippet", page.snippet().text());
     page_value->SetBoolean(
         "starred",
         BookmarkModelFactory::GetForProfile(
             provider_->profile())->IsBookmarked(page.url()));
     history_list->Append(page_value);
   }
 
   return_value->Set("history", history_list);
   // Return history info.
-  AutomationJSONReply reply(provider_, reply_message_.release());
+  AutomationJSONReply reply(provider_.get(), reply_message_.release());
   reply.SendSuccess(return_value.get());
   delete this;
 }
 
 AutomationProviderImportSettingsObserver::
 AutomationProviderImportSettingsObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message)
     : provider_(provider->AsWeakPtr()),
       reply_message_(reply_message) {
 }
 
 AutomationProviderImportSettingsObserver::
     ~AutomationProviderImportSettingsObserver() {}
 
 void AutomationProviderImportSettingsObserver::ImportStarted() {
 }
 
 void AutomationProviderImportSettingsObserver::ImportItemStarted(
     importer::ImportItem item) {
 }
 
 void AutomationProviderImportSettingsObserver::ImportItemEnded(
     importer::ImportItem item) {
 }
 
 void AutomationProviderImportSettingsObserver::ImportEnded() {
-  if (provider_)
-    AutomationJSONReply(provider_, reply_message_.release()).SendSuccess(NULL);
+  if (provider_.get())
+    AutomationJSONReply(provider_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   delete this;
 }
 
 AutomationProviderGetPasswordsObserver::AutomationProviderGetPasswordsObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message)
     : provider_(provider->AsWeakPtr()),
       reply_message_(reply_message) {
 }
 
 AutomationProviderGetPasswordsObserver::
     ~AutomationProviderGetPasswordsObserver() {}
 
 void AutomationProviderGetPasswordsObserver::OnPasswordStoreRequestDone(
     CancelableRequestProvider::Handle handle,
     const std::vector<content::PasswordForm*>& result) {
-  if (!provider_) {
+  if (!provider_.get()) {
     delete this;
     return;
   }
 
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   ListValue* passwords = new ListValue;
   for (std::vector<content::PasswordForm*>::const_iterator it =
            result.begin(); it != result.end(); ++it) {
     DictionaryValue* password_val = new DictionaryValue;
     content::PasswordForm* password_form = *it;
     password_val->SetString("username_value", password_form->username_value);
     password_val->SetString("password_value", password_form->password_value);
     password_val->SetString("signon_realm", password_form->signon_realm);
     password_val->SetDouble(
         "time", static_cast<double>(password_form->date_created.ToDoubleT()));
     password_val->SetString("origin_url", password_form->origin.spec());
     password_val->SetString("username_element",
                             password_form->username_element);
     password_val->SetString("password_element",
                             password_form->password_element);
     password_val->SetString("submit_element", password_form->submit_element);
     password_val->SetString("action_target", password_form->action.spec());
     password_val->SetBoolean("blacklist", password_form->blacklisted_by_user);
     passwords->Append(password_val);
   }
 
   return_value->Set("passwords", passwords);
-  AutomationJSONReply(provider_, reply_message_.release()).SendSuccess(
-      return_value.get());
+  AutomationJSONReply(provider_.get(), reply_message_.release())
+      .SendSuccess(return_value.get());
   delete this;
 }
 
 void AutomationProviderGetPasswordsObserver::OnGetPasswordStoreResults(
     const std::vector<content::PasswordForm*>& results) {
   // TODO(kaiwang): Implement when I refactor
   // PasswordManager::GetAutofillableLogins.
   NOTIMPLEMENTED();
 }
 
@@ skipping 55 matching lines @@
 
   // Notify the UI thread that we're done listening.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&PasswordStoreLoginsChangedObserver::IndicateDone, this));
 }
 
 void PasswordStoreLoginsChangedObserver::IndicateDone() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (automation_) {
+  if (automation_.get()) {
     if (result_key_.empty()) {
-      AutomationJSONReply(automation_, reply_message_.release())
+      AutomationJSONReply(automation_.get(), reply_message_.release())
           .SendSuccess(NULL);
     } else {
       scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
       return_value->SetBoolean(result_key_, true);
-      AutomationJSONReply(automation_, reply_message_.release())
+      AutomationJSONReply(automation_.get(), reply_message_.release())
           .SendSuccess(return_value.get());
     }
   }
   Release();
 }
 
 void PasswordStoreLoginsChangedObserver::IndicateError(
     const std::string& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (automation_)
-    AutomationJSONReply(automation_, reply_message_.release()).SendError(error);
+  if (automation_.get())
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendError(error);
   Release();
 }
 
 OmniboxAcceptNotificationObserver::OmniboxAcceptNotificationObserver(
     NavigationController* controller,
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       controller_(controller) {
   content::Source<NavigationController> source(controller_);
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP, source);
   // Pages requiring auth don't send LOAD_STOP.
   registrar_.Add(this, chrome::NOTIFICATION_AUTH_NEEDED, source);
 }
 
 OmniboxAcceptNotificationObserver::~OmniboxAcceptNotificationObserver() {
 }
 
 void OmniboxAcceptNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == content::NOTIFICATION_LOAD_STOP ||
       type == chrome::NOTIFICATION_AUTH_NEEDED) {
-    if (automation_) {
-      AutomationJSONReply(automation_,
-                          reply_message_.release()).SendSuccess(NULL);
+    if (automation_.get()) {
+      AutomationJSONReply(automation_.get(), reply_message_.release())
+          .SendSuccess(NULL);
     }
     delete this;
   } else {
     NOTREACHED();
   }
 }
 
 SavePackageNotificationObserver::SavePackageNotificationObserver(
     content::DownloadManager* download_manager,
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : download_manager_(download_manager),
       automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   download_manager_->AddObserver(this);
 }
 
 SavePackageNotificationObserver::~SavePackageNotificationObserver() {
   download_manager_->RemoveObserver(this);
 }
 
 void SavePackageNotificationObserver::OnSavePackageSuccessfullyFinished(
     content::DownloadManager* manager, content::DownloadItem* item) {
-  if (automation_) {
-    AutomationJSONReply(automation_,
-                        reply_message_.release()).SendSuccess(NULL);
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   }
   delete this;
 }
 
 void SavePackageNotificationObserver::ManagerGoingDown(
     content::DownloadManager* manager) {
   delete this;
 }
 
 namespace {
@@ skipping 43 matching lines @@
 }  // namespace
 
 NTPInfoObserver::NTPInfoObserver(AutomationProvider* automation,
                                  IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       request_(0),
       ntp_info_(new DictionaryValue) {
   top_sites_ = automation_->profile()->GetTopSites();
   if (!top_sites_) {
-    AutomationJSONReply(automation_, reply_message_.release())
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendError("Profile does not have service for querying the top sites.");
     return;
   }
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(automation_->profile());
   if (!service) {
-    AutomationJSONReply(automation_, reply_message_.release())
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendError("No TabRestoreService.");
     return;
   }
 
   // Collect information about the apps in the new tab page.
   ExtensionService* ext_service = extensions::ExtensionSystem::Get(
       automation_->profile())->extension_service();
   if (!ext_service) {
-    AutomationJSONReply(automation_, reply_message_.release())
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendError("No ExtensionService.");
     return;
   }
   // Process enabled extensions.
   ListValue* apps_list = new ListValue();
   const ExtensionSet* extensions = ext_service->extensions();
   std::vector<DictionaryValue*>* enabled_apps = GetAppInfoFromExtensions(
       extensions, ext_service);
   for (std::vector<DictionaryValue*>::const_iterator app =
        enabled_apps->begin(); app != enabled_apps->end(); ++app) {
@@ skipping 66 matching lines @@
     }
   }
 }
 
 void NTPInfoObserver::OnTopSitesLoaded() {
   request_ = top_sites_->StartQueryForMostVisited();
 }
 
 void NTPInfoObserver::OnTopSitesReceived(
     const history::MostVisitedURLList& visited_list) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   ListValue* list_value = new ListValue;
   for (size_t i = 0; i < visited_list.size(); ++i) {
     const history::MostVisitedURL& visited = visited_list[i];
     if (visited.url.spec().empty())
       break;  // This is the signal that there are no more real visited sites.
     DictionaryValue* dict = new DictionaryValue;
     dict->SetString("url", visited.url.spec());
     dict->SetString("title", visited.title);
     list_value->Append(dict);
   }
   ntp_info_->Set("most_visited", list_value);
-  AutomationJSONReply(automation_,
-                      reply_message_.release()).SendSuccess(ntp_info_.get());
+  AutomationJSONReply(automation_.get(), reply_message_.release())
+      .SendSuccess(ntp_info_.get());
   delete this;
 }
 
 AppLaunchObserver::AppLaunchObserver(
     NavigationController* controller,
     AutomationProvider* automation,
     IPC::Message* reply_message,
     extension_misc::LaunchContainer launch_container)
     : controller_(controller),
       automation_(automation->AsWeakPtr()),
@@ skipping 23 matching lines @@
         ExtensionTabUtil::GetWindowId(content::Source<Browser>(source).ptr());
     return;
   }
 
   DCHECK_EQ(content::NOTIFICATION_LOAD_STOP, type);
   SessionTabHelper* session_tab_helper = SessionTabHelper::FromWebContents(
       content::Source<NavigationController>(source)->GetWebContents());
   if ((launch_container_ == extension_misc::LAUNCH_TAB) ||
       (session_tab_helper &&
           (session_tab_helper->window_id().id() == new_window_id_))) {
-    if (automation_) {
-      AutomationJSONReply(automation_,
-                          reply_message_.release()).SendSuccess(NULL);
+    if (automation_.get()) {
+      AutomationJSONReply(automation_.get(), reply_message_.release())
+          .SendSuccess(NULL);
     }
     delete this;
   }
 }
 
 namespace {
 
 // Returns whether all active notifications have an associated process ID.
 bool AreActiveNotificationProcessesReady() {
   BalloonNotificationUIManager* manager =
@@ skipping 23 matching lines @@
                    content::NotificationService::AllSources());
   }
 }
 
 GetAllNotificationsObserver::~GetAllNotificationsObserver() {}
 
 void GetAllNotificationsObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
   if (AreActiveNotificationProcessesReady())
     SendMessage();
 }
 
 base::DictionaryValue* GetAllNotificationsObserver::NotificationToJson(
     const Notification* note) {
   DictionaryValue* dict = new base::DictionaryValue();
@@ skipping 25 matching lines @@
     }
     list->Append(note);
   }
   std::vector<const Notification*> queued_notes;
   manager->GetQueuedNotificationsForTesting(&queued_notes);
   std::vector<const Notification*>::const_iterator queued_iter;
   for (queued_iter = queued_notes.begin(); queued_iter != queued_notes.end();
        ++queued_iter) {
     list->Append(NotificationToJson(*queued_iter));
   }
-  AutomationJSONReply(automation_,
-                      reply_message_.release()).SendSuccess(&return_value);
+  AutomationJSONReply(automation_.get(), reply_message_.release())
+      .SendSuccess(&return_value);
   delete this;
 }
 
 NewNotificationBalloonObserver::NewNotificationBalloonObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message)
     : automation_(provider->AsWeakPtr()),
       reply_message_(reply_message) {
   registrar_.Add(this, chrome::NOTIFICATION_NOTIFY_BALLOON_CONNECTED,
                  content::NotificationService::AllSources());
 }
 
 NewNotificationBalloonObserver::~NewNotificationBalloonObserver() { }
 
 void NewNotificationBalloonObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (automation_) {
-    AutomationJSONReply(automation_,
-                        reply_message_.release()).SendSuccess(NULL);
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   }
   delete this;
 }
 
 OnNotificationBalloonCountObserver::OnNotificationBalloonCountObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message,
     int count)
     : automation_(provider->AsWeakPtr()),
       reply_message_(reply_message),
@@ skipping 15 matching lines @@
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   CheckBalloonCount();
 }
 
 void OnNotificationBalloonCountObserver::CheckBalloonCount() {
   bool balloon_count_met = AreActiveNotificationProcessesReady() &&
       static_cast<int>(collection_->GetActiveBalloons().size()) == count_;
 
-  if (balloon_count_met && automation_) {
-    AutomationJSONReply(automation_,
-                        reply_message_.release()).SendSuccess(NULL);
+  if (balloon_count_met && automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   }
 
-  if (balloon_count_met || !automation_) {
+  if (balloon_count_met || !automation_.get()) {
     collection_->set_on_collection_changed_callback(base::Closure());
     delete this;
   }
 }
 
 RendererProcessClosedObserver::RendererProcessClosedObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
 }
 
 RendererProcessClosedObserver::~RendererProcessClosedObserver() {}
 
 void RendererProcessClosedObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (automation_) {
-    AutomationJSONReply(automation_,
-                        reply_message_.release()).SendSuccess(NULL);
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   }
   delete this;
 }
 
 InputEventAckNotificationObserver::InputEventAckNotificationObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message,
     int event_type,
     int count)
     : automation_(automation->AsWeakPtr()),
@@ skipping 11 matching lines @@
       content::NotificationService::AllSources());
 }
 
 InputEventAckNotificationObserver::~InputEventAckNotificationObserver() {}
 
 void InputEventAckNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN) {
-    AutomationJSONReply(automation_,
-                        reply_message_.release()).SendSuccess(NULL);
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendSuccess(NULL);
     delete this;
     return;
   }
 
   content::Details<int> request_details(details);
   // If the event type matches for |count_| times, replies with a JSON message.
   if (event_type_ == *request_details.ptr()) {
-    if (--count_ == 0 && automation_) {
-      AutomationJSONReply(automation_,
-                          reply_message_.release()).SendSuccess(NULL);
+    if (--count_ == 0 && automation_.get()) {
+      AutomationJSONReply(automation_.get(), reply_message_.release())
+          .SendSuccess(NULL);
       delete this;
     }
   } else {
     LOG(WARNING) << "Ignoring unexpected event type: "
                  << *request_details.ptr() << " (expected: " << event_type_
                  << ")";
   }
 }
 
 NewTabObserver::NewTabObserver(AutomationProvider* automation,
                                IPC::Message* reply_message,
                                bool use_json_interface)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       use_json_interface_(use_json_interface) {
   // Use TAB_PARENTED to detect the new tab.
   registrar_.Add(this,
                  chrome::NOTIFICATION_TAB_PARENTED,
                  content::NotificationService::AllSources());
 }
 
 void NewTabObserver::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_TAB_PARENTED, type);
   NavigationController* controller =
       &(content::Source<content::WebContents>(source).ptr()->GetController());
-  if (automation_) {
+  if (automation_.get()) {
     // TODO(phajdan.jr): Clean up this hack. We write the correct return type
     // here, but don't send the message. NavigationNotificationObserver
     // will wait properly for the load to finish, and send the message,
     // but it will also append its own return value at the end of the reply.
     if (!use_json_interface_)
       AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message_.get(),
                                                            true);
-    new NavigationNotificationObserver(controller, automation_,
+    new NavigationNotificationObserver(controller,
+                                       automation_.get(),
                                        reply_message_.release(),
-                                       1, false, use_json_interface_);
+                                       1,
+                                       false,
+                                       use_json_interface_);
   }
   delete this;
 }
 
 NewTabObserver::~NewTabObserver() {
 }
 
 WaitForProcessLauncherThreadToGoIdleObserver::
 WaitForProcessLauncherThreadToGoIdleObserver(
     AutomationProvider* automation, IPC::Message* reply_message)
@@ skipping 28 matching lines @@
 RunOnProcessLauncherThread2() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&WaitForProcessLauncherThreadToGoIdleObserver::RunOnUIThread,
                  this));
 }
 
 void WaitForProcessLauncherThreadToGoIdleObserver::RunOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (automation_)
+  if (automation_.get())
     automation_->Send(reply_message_.release());
   Release();
 }
 
 DragTargetDropAckNotificationObserver::DragTargetDropAckNotificationObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   registrar_.Add(
       this,
       content::NOTIFICATION_RENDER_VIEW_HOST_DID_RECEIVE_DRAG_TARGET_DROP_ACK,
       content::NotificationService::AllSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
       content::NotificationService::AllSources());
 }
 
 DragTargetDropAckNotificationObserver::
     ~DragTargetDropAckNotificationObserver() {}
 
 void DragTargetDropAckNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (automation_) {
-    AutomationJSONReply(automation_,
-                        reply_message_.release()).SendSuccess(NULL);
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
+        .SendSuccess(NULL);
   }
   delete this;
 }
 
 ProcessInfoObserver::ProcessInfoObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {}
 
@@ skipping 62 matching lines @@
       proc_data->Set("titles", titles);
 
       proc_list->Append(proc_data);
     }
     browser_data->Set("processes", proc_list);
 
     browser_proc_list->Append(browser_data);
   }
   return_value->Set("browsers", browser_proc_list);
 
-  if (automation_) {
-    AutomationJSONReply(automation_, reply_message_.release())
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendSuccess(return_value.get());
   }
 }
 
 V8HeapStatsObserver::V8HeapStatsObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message,
     base::ProcessId renderer_id)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
@@ skipping 21 matching lines @@
   ChromeRenderMessageFilter::V8HeapStatsDetails* v8_heap_details =
       content::Details<ChromeRenderMessageFilter::V8HeapStatsDetails>(details)
           .ptr();
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   return_value->SetInteger("renderer_id", updated_renderer_id);
   return_value->SetInteger("v8_memory_allocated",
                            v8_heap_details->v8_memory_allocated());
   return_value->SetInteger("v8_memory_used",
                            v8_heap_details->v8_memory_used());
 
-  if (automation_) {
-    AutomationJSONReply(automation_, reply_message_.release())
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendSuccess(return_value.get());
   }
   delete this;
 }
 
 FPSObserver::FPSObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message,
     base::ProcessId renderer_id,
     int routing_id)
@@ skipping 25 matching lines @@
       content::Details<ChromeRenderMessageFilter::FPSDetails>(details).ptr();
   // Only return information for the routing id of the host render view we're
   // interested in.
   if (routing_id_ != fps_details->routing_id())
     return;
 
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   return_value->SetInteger("renderer_id", updated_renderer_id);
   return_value->SetInteger("routing_id", fps_details->routing_id());
   return_value->SetDouble("fps", fps_details->fps());
-  if (automation_) {
-    AutomationJSONReply(automation_, reply_message_.release())
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendSuccess(return_value.get());
   }
   delete this;
 }
 
 BrowserOpenedWithNewProfileNotificationObserver::
     BrowserOpenedWithNewProfileNotificationObserver(
         AutomationProvider* automation,
         IPC::Message* reply_message)
         : automation_(automation->AsWeakPtr()),
           reply_message_(reply_message),
           new_window_id_(extension_misc::kUnknownWindowId) {
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 BrowserOpenedWithNewProfileNotificationObserver::
     ~BrowserOpenedWithNewProfileNotificationObserver() {
 }
 
 void BrowserOpenedWithNewProfileNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   if (type == chrome::NOTIFICATION_PROFILE_CREATED) {
     // As part of multi-profile creation, a new browser window will
     // automatically be opened.
     Profile* profile = content::Source<Profile>(source).ptr();
     if (!profile) {
-      AutomationJSONReply(automation_,
-          reply_message_.release()).SendError("Profile could not be created.");
+      AutomationJSONReply(automation_.get(), reply_message_.release())
+          .SendError("Profile could not be created.");
       return;
     }
   } else if (type == chrome::NOTIFICATION_BROWSER_OPENED) {
     // Store the new browser ID and continue waiting for a new tab within it
     // to stop loading.
     new_window_id_ = ExtensionTabUtil::GetWindowId(
         content::Source<Browser>(source).ptr());
   } else {
     DCHECK_EQ(content::NOTIFICATION_LOAD_STOP, type);
     // Only send the result if the loaded tab is in the new window.
     NavigationController* controller =
         content::Source<NavigationController>(source).ptr();
     SessionTabHelper* session_tab_helper =
         SessionTabHelper::FromWebContents(controller->GetWebContents());
     int window_id = session_tab_helper ? session_tab_helper->window_id().id()
                                        : -1;
     if (window_id == new_window_id_) {
-      if (automation_) {
-        AutomationJSONReply(automation_, reply_message_.release())
+      if (automation_.get()) {
+        AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendSuccess(NULL);
       }
       delete this;
     }
   }
 }
 
 ExtensionPopupObserver::ExtensionPopupObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message,
     const std::string& extension_id)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       extension_id_(extension_id) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
                  content::NotificationService::AllSources());
 }
 
 ExtensionPopupObserver::~ExtensionPopupObserver() {
 }
 
 void ExtensionPopupObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   extensions::ExtensionHost* host =
       content::Details<extensions::ExtensionHost>(details).ptr();
   if (host->extension_id() == extension_id_ &&
       host->extension_host_type() == extensions::VIEW_TYPE_EXTENSION_POPUP) {
-    AutomationJSONReply(automation_, reply_message_.release())
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendSuccess(NULL);
     delete this;
   }
 }
 
 #if defined(OS_LINUX)
 WindowMaximizedObserver::WindowMaximizedObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_MAXIMIZED,
                  content::NotificationService::AllSources());
 }
 
 WindowMaximizedObserver::~WindowMaximizedObserver() {}
 
 void WindowMaximizedObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_BROWSER_WINDOW_MAXIMIZED, type);
 
-  if (automation_) {
-    AutomationJSONReply(automation_, reply_message_.release())
+  if (automation_.get()) {
+    AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendSuccess(NULL);
   }
   delete this;
 }
 #endif  // defined(OS_LINUX)
 
 BrowserOpenedWithExistingProfileNotificationObserver::
     BrowserOpenedWithExistingProfileNotificationObserver(
         AutomationProvider* automation,
         IPC::Message* reply_message,
         int num_loads)
         : automation_(automation->AsWeakPtr()),
           reply_message_(reply_message),
           new_window_id_(extension_misc::kUnknownWindowId),
           num_loads_(num_loads) {
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 BrowserOpenedWithExistingProfileNotificationObserver::
     ~BrowserOpenedWithExistingProfileNotificationObserver() {
 }
 
 void BrowserOpenedWithExistingProfileNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  if (!automation_) {
+  if (!automation_.get()) {
     delete this;
     return;
   }
 
   if (type == chrome::NOTIFICATION_BROWSER_OPENED) {
     // Store the new browser ID and continue waiting for NOTIFICATION_LOAD_STOP.
     new_window_id_ = ExtensionTabUtil::GetWindowId(
         content::Source<Browser>(source).ptr());
   } else if (type == content::NOTIFICATION_LOAD_STOP) {
     // Only consider if the loaded tab is in the new window.
     NavigationController* controller =
         content::Source<NavigationController>(source).ptr();
     SessionTabHelper* session_tab_helper =
         SessionTabHelper::FromWebContents(controller->GetWebContents());
     int window_id = session_tab_helper ? session_tab_helper->window_id().id()
                                        : -1;
     if (window_id == new_window_id_ && --num_loads_ == 0) {
-      if (automation_) {
-        AutomationJSONReply(automation_, reply_message_.release())
+      if (automation_.get()) {
+        AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendSuccess(NULL);
       }
       delete this;
     }
   } else {
     NOTREACHED();
   }
 }