Cleanup: Remove unnecessary ".get()" from scoped_ptrs<>.

ash/system/tray/system_tray.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 "ash/system/tray/system_tray.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/shell/panel_window.h"
@@ skipping 195 matching lines @@
                             TrayBubbleView::InitParams::kArrowDefaultOffset);
 }
 
 void SystemTray::ShowDetailedView(SystemTrayItem* item,
                                   int close_delay,
                                   bool activate,
                                   BubbleCreationType creation_type) {
   std::vector<SystemTrayItem*> items;
   items.push_back(item);
   ShowItems(items, true, activate, creation_type, GetTrayXOffset(item));
-  if (system_bubble_.get())
+  if (system_bubble_)
     system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::SetDetailedViewCloseDelay(int close_delay) {
   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DETAILED))
     system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::HideDetailedView(SystemTrayItem* item) {
   if (item != detailed_item_)
@@ skipping 10 matching lines @@
   UpdateNotificationBubble();
 }
 
 void SystemTray::HideNotificationView(SystemTrayItem* item) {
   std::vector<SystemTrayItem*>::iterator found_iter =
       std::find(notification_items_.begin(), notification_items_.end(), item);
   if (found_iter == notification_items_.end())
     return;
   notification_items_.erase(found_iter);
   // Only update the notification bubble if visible (i.e. don't create one).
-  if (notification_bubble_.get())
+  if (notification_bubble_)
     UpdateNotificationBubble();
 }
 
 void SystemTray::UpdateAfterLoginStatusChange(user::LoginStatus login_status) {
   DestroySystemBubble();
   UpdateNotificationBubble();
 
   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
       it != items_.end();
       ++it) {
     (*it)->UpdateAfterLoginStatusChange(login_status);
   }
 
   SetVisible(true);
   PreferredSizeChanged();
 }
 
 void SystemTray::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
       it != items_.end();
       ++it) {
     (*it)->UpdateAfterShelfAlignmentChange(alignment);
   }
 }
 
 void SystemTray::SetHideNotifications(bool hide_notifications) {
-  if (notification_bubble_.get())
+  if (notification_bubble_)
     notification_bubble_->bubble()->SetVisible(!hide_notifications);
   hide_notifications_ = hide_notifications;
 }
 
 bool SystemTray::ShouldShowLauncher() const {
   return system_bubble_.get() && system_bubble_->bubble()->ShouldShowLauncher();
 }
 
 bool SystemTray::HasSystemBubble() const {
   return system_bubble_.get() != NULL;
 }
 
 bool SystemTray::HasNotificationBubble() const {
   return notification_bubble_.get() != NULL;
 }
 
 internal::SystemTrayBubble* SystemTray::GetSystemBubble() {
-  if (!system_bubble_.get())
+  if (!system_bubble_)
     return NULL;
   return system_bubble_->bubble();
 }
 
 bool SystemTray::IsAnyBubbleVisible() const {
   return ((system_bubble_.get() &&
            system_bubble_->bubble()->IsVisible()) ||
           (notification_bubble_.get() &&
            notification_bubble_->bubble()->IsVisible()));
 }
 
 bool SystemTray::IsMouseInNotificationBubble() const {
-  if (!notification_bubble_.get())
+  if (!notification_bubble_)
     return false;
   return notification_bubble_->bubble_view()->GetBoundsInScreen().Contains(
       Shell::GetScreen()->GetCursorScreenPoint());
 }
 
 bool SystemTray::CloseSystemBubbleForTest() const {
-  if (!system_bubble_.get())
+  if (!system_bubble_)
     return false;
   system_bubble_->bubble()->Close();
   return true;
 }
 
 bool SystemTray::CloseNotificationBubbleForTest() const {
-  if (!notification_bubble_.get())
+  if (!notification_bubble_)
     return false;
   notification_bubble_->bubble()->Close();
   return true;
 }
 
 // Private methods.
 
 bool SystemTray::HasSystemBubbleType(SystemTrayBubble::BubbleType type) {
   DCHECK(type != SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
   return system_bubble_.get() && system_bubble_->bubble_type() == type;
@@ skipping 137 matching lines @@
 }
 
 void SystemTray::SetShelfAlignment(ShelfAlignment alignment) {
   if (alignment == shelf_alignment())
     return;
   internal::TrayBackgroundView::SetShelfAlignment(alignment);
   UpdateAfterShelfAlignmentChange(alignment);
   // Destroy any existing bubble so that it is rebuilt correctly.
   system_bubble_.reset();
   // Rebuild any notification bubble.
-  if (notification_bubble_.get()) {
+  if (notification_bubble_) {
     notification_bubble_.reset();
     UpdateNotificationBubble();
   }
 }
 
 void SystemTray::AnchorUpdated() {
-  if (notification_bubble_.get()) {
+  if (notification_bubble_) {
     notification_bubble_->bubble_view()->UpdateBubble();
     // Ensure that the notification buble is above the launcher/status area.
     notification_bubble_->bubble_view()->GetWidget()->StackAtTop();
     UpdateBubbleViewArrow(notification_bubble_->bubble_view());
   }
-  if (system_bubble_.get()) {
+  if (system_bubble_) {
     system_bubble_->bubble_view()->UpdateBubble();
     UpdateBubbleViewArrow(system_bubble_->bubble_view());
   }
 }
 
 base::string16 SystemTray::GetAccessibleNameForTray() {
   return l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBLE_NAME);
 }
 
 void SystemTray::HideBubbleWithView(const TrayBubbleView* bubble_view) {
   if (system_bubble_.get() && bubble_view == system_bubble_->bubble_view()) {
     DestroySystemBubble();
     UpdateNotificationBubble();  // State changed, re-create notifications.
     GetShelfLayoutManager()->UpdateAutoHideState();
   } else if (notification_bubble_.get() &&
              bubble_view == notification_bubble_->bubble_view()) {
     DestroyNotificationBubble();
   }
 }
 
 bool SystemTray::ClickedOutsideBubble() {
-  if (!system_bubble_.get())
+  if (!system_bubble_)
     return false;
   HideBubbleWithView(system_bubble_->bubble_view());
   return true;
 }
 
 void SystemTray::BubbleViewDestroyed() {
-  if (system_bubble_.get()) {
+  if (system_bubble_) {
     system_bubble_->bubble()->DestroyItemViews();
     system_bubble_->bubble()->BubbleViewDestroyed();
   }
 }
 
 void SystemTray::OnMouseEnteredView() {
-  if (system_bubble_.get())
+  if (system_bubble_)
     system_bubble_->bubble()->StopAutoCloseTimer();
 }
 
 void SystemTray::OnMouseExitedView() {
-  if (system_bubble_.get())
+  if (system_bubble_)
     system_bubble_->bubble()->RestartAutoCloseTimer();
 }
 
 base::string16 SystemTray::GetAccessibleNameForBubble() {
   return GetAccessibleNameForTray();
 }
 
 gfx::Rect SystemTray::GetAnchorRect(
     views::Widget* anchor_widget,
     TrayBubbleView::AnchorType anchor_type,
@@ skipping 21 matching lines @@
         ConvertPointToWidget(this, &point);
         arrow_offset = point.x();
       }
     }
     ShowDefaultViewWithOffset(BUBBLE_CREATE_NEW, arrow_offset);
   }
   return true;
 }
 
 }  // namespace ash