Removal of drag window to user tray icon functionality

ash/system/user/tray_user.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/user/tray_user.h"
 
 #include <algorithm>
 #include <climits>
 #include <vector>
 
@@ skipping 158 matching lines @@
   gfx::Size image_size_;
   int corner_radius_[4];
 
   // True if the given user is the active user and the icon should get
   // painted as active.
   bool active_user_;
 
   DISALLOW_COPY_AND_ASSIGN(RoundedImageView);
 };
 
-// An inactive user view which can be clicked to make active. Note that this
-// "button" does not show as a button any click or hover changes.
-class UserSwitcherView : public RoundedImageView {
- public:
-  UserSwitcherView(int corner_radius, MultiProfileIndex user_index);
-  virtual ~UserSwitcherView() {}
-
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
-
- private:
-  // The user index to activate when the item was clicked. Note that this
-  // index refers to the LRU list of logged in users.
-  MultiProfileIndex user_index_;
-
-  DISALLOW_COPY_AND_ASSIGN(UserSwitcherView);
-};
-
 // The user details shown in public account mode. This is essentially a label
 // but with custom painting code as the text is styled with multiple colors and
 // contains a link.
 class PublicAccountUserDetails : public views::View,
                                  public views::LinkListener {
  public:
   PublicAccountUserDetails(SystemTrayItem* owner, int used_width);
   virtual ~PublicAccountUserDetails();
 
  private:
@@ skipping 232 matching lines @@
   SkPath path;
   path.addRoundRect(gfx::RectToSkRect(image_bounds), kRadius);
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setXfermodeMode(active_user_ ? SkXfermode::kSrcOver_Mode :
                                        SkXfermode::kLuminosity_Mode);
   canvas->DrawImageInPath(resized_, image_bounds.x(), image_bounds.y(),
                           path, paint);
 }
 
-UserSwitcherView::UserSwitcherView(int corner_radius,
-                                   MultiProfileIndex user_index)
-    : RoundedImageView(corner_radius, false),
-      user_index_(user_index) {
-  SetEnabled(true);
-}
-
-void UserSwitcherView::OnMouseEvent(ui::MouseEvent* event) {
-  if (event->type() == ui::ET_MOUSE_PRESSED) {
-    SwitchUser(user_index_);
-    event->SetHandled();
-  }
-}
-
-void UserSwitcherView::OnTouchEvent(ui::TouchEvent* event) {
-  if (event->type() == ui::ET_TOUCH_PRESSED) {
-    SwitchUser(user_index_);
-    event->SetHandled();
-  }
-}
-
 PublicAccountUserDetails::PublicAccountUserDetails(SystemTrayItem* owner,
                                                    int used_width)
     : learn_more_(NULL) {
   const int inner_padding =
       kTrayPopupPaddingHorizontal - kTrayPopupPaddingBetweenItems;
   const bool rtl = base::i18n::IsRTL();
   SetBorder(views::Border::CreateEmptyBorder(kUserDetailsVerticalPadding,
                                              rtl ? 0 : inner_padding,
                                              kUserDetailsVerticalPadding,
                                              rtl ? inner_padding : 0));
@@ skipping 666 matching lines @@
 TrayUser::~TrayUser() {
   Shell::GetInstance()->system_tray_notifier()->RemoveUserObserver(this);
 }
 
 TrayUser::TestState TrayUser::GetStateForTest() const {
   if (!user_)
     return HIDDEN;
   return user_->GetStateForTest();
 }
 
-bool TrayUser::CanDropWindowHereToTransferToUser(
-    const gfx::Point& point_in_screen) {
-  // Check that this item is shown in the system tray (which means it must have
-  // a view there) and that the user it represents is not the current user (in
-  // which case |GetTrayIndex()| would return NULL).
-  if (!layout_view_ || !GetTrayIndex())
-    return false;
-  return layout_view_->GetBoundsInScreen().Contains(point_in_screen);
-}
-
-bool TrayUser::TransferWindowToUser(aura::Window* window) {
-  SessionStateDelegate* session_state_delegate =
-      ash::Shell::GetInstance()->session_state_delegate();
-  return session_state_delegate->TransferWindowToDesktopOfUser(window,
-                                                               GetTrayIndex());
-}
-
 gfx::Rect TrayUser::GetUserPanelBoundsInScreenForTest() const {
   DCHECK(user_);
   return user_->GetBoundsInScreenOfUserButtonForTest();
 }
 
 views::View* TrayUser::CreateTrayView(user::LoginStatus status) {
   CHECK(layout_view_ == NULL);
 
   layout_view_ = new views::View();
   layout_view_->SetLayoutManager(
@@ skipping 39 matching lines @@
   user_ = NULL;
 }
 
 void TrayUser::DestroyDetailedView() {
 }
 
 void TrayUser::UpdateAfterLoginStatusChange(user::LoginStatus status) {
   // Only the active user is represented in the tray.
   if (!layout_view_)
     return;
-  if (GetTrayIndex() > 0 && !ash::switches::UseMultiUserTray())
+  if (GetTrayIndex() > 0)
     return;
   bool need_label = false;
   bool need_avatar = false;
   switch (status) {
     case user::LOGGED_IN_LOCKED:
     case user::LOGGED_IN_USER:
     case user::LOGGED_IN_OWNER:
     case user::LOGGED_IN_PUBLIC:
       need_avatar = true;
       break;
@@ skipping 14 matching lines @@
       (need_label != (label_ != NULL))) {
     layout_view_->RemoveAllChildViews(true);
     if (need_label) {
       label_ = new views::Label;
       SetupLabelForTray(label_);
       layout_view_->AddChildView(label_);
     } else {
       label_ = NULL;
     }
     if (need_avatar) {
-      MultiProfileIndex tray_index = GetTrayIndex();
-      if (!tray_index) {
-        // The active user (index #0) will always be the first.
-        avatar_ = new tray::RoundedImageView(kProfileRoundedCornerRadius, true);
-      } else {
-        // All other users will be inactive users.
-        avatar_ = new tray::UserSwitcherView(kProfileRoundedCornerRadius,
-                                             tray_index);
-      }
+      avatar_ = new tray::RoundedImageView(kProfileRoundedCornerRadius, true);
       layout_view_->AddChildView(avatar_);
     } else {
       avatar_ = NULL;
     }
   }
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   if (status == user::LOGGED_IN_LOCALLY_MANAGED) {
     label_->SetText(
         bundle.GetLocalizedString(IDS_ASH_STATUS_TRAY_LOCALLY_MANAGED_LABEL));
   } else if (status == user::LOGGED_IN_GUEST) {
     label_->SetText(bundle.GetLocalizedString(IDS_ASH_STATUS_TRAY_GUEST_LABEL));
   }
 
   if (avatar_ && switches::UseAlternateShelfLayout()) {
-    int corner_radius = GetTrayItemRadius();
-    avatar_->SetCornerRadii(0, corner_radius, corner_radius, 0);
+    avatar_->SetCornerRadii(
+        0, kUserIconLargeCornerRadius, kUserIconLargeCornerRadius, 0);
     avatar_->SetBorder(views::Border::NullBorder());
   }
   UpdateAvatarImage(status);
 
   // Update layout after setting label_ and avatar_ with new login status.
   UpdateLayoutOfItem();
 }
 
 void TrayUser::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
   // Inactive users won't have a layout.
   if (!layout_view_)
     return;
-  int corner_radius = GetTrayItemRadius();
   if (alignment == SHELF_ALIGNMENT_BOTTOM ||
       alignment == SHELF_ALIGNMENT_TOP) {
     if (avatar_) {
       if (switches::UseAlternateShelfLayout()) {
-        if (multiprofile_index_) {
-          avatar_->SetBorder(
-              views::Border::CreateEmptyBorder(0, kTrayLabelSpacing, 0, 0));
-        } else {
-          avatar_->SetBorder(views::Border::NullBorder());
-        }
-        avatar_->SetCornerRadii(0, corner_radius, corner_radius, 0);
+        avatar_->SetBorder(views::Border::NullBorder());
+        avatar_->SetCornerRadii(
+            0, kUserIconLargeCornerRadius, kUserIconLargeCornerRadius, 0);
       } else {
         avatar_->SetBorder(views::Border::CreateEmptyBorder(
             0,
             kTrayImageItemHorizontalPaddingBottomAlignment + 2,
             0,
             kTrayImageItemHorizontalPaddingBottomAlignment));
       }
     }
     if (label_) {
       label_->SetBorder(views::Border::CreateEmptyBorder(
           0,
           kTrayLabelItemHorizontalPaddingBottomAlignment,
           0,
           kTrayLabelItemHorizontalPaddingBottomAlignment));
     }
     layout_view_->SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kHorizontal,
                              0, 0, kUserLabelToIconPadding));
   } else {
     if (avatar_) {
       if (switches::UseAlternateShelfLayout()) {
-        if (multiprofile_index_) {
-          avatar_->SetBorder(
-              views::Border::CreateEmptyBorder(kTrayLabelSpacing, 0, 0, 0));
-        } else {
-          avatar_->SetBorder(views::Border::NullBorder());
-        }
-        avatar_->SetCornerRadii(0, 0, corner_radius, corner_radius);
+        avatar_->SetBorder(views::Border::NullBorder());
+        avatar_->SetCornerRadii(
+            0, 0, kUserIconLargeCornerRadius, kUserIconLargeCornerRadius);
       } else {
         SetTrayImageItemBorder(avatar_, alignment);
       }
     }
     if (label_) {
       label_->SetBorder(views::Border::CreateEmptyBorder(
           kTrayLabelItemVerticalPaddingVerticalAlignment,
           kTrayLabelItemHorizontalPaddingBottomAlignment,
           kTrayLabelItemVerticalPaddingVerticalAlignment,
           kTrayLabelItemHorizontalPaddingBottomAlignment));
@@ skipping 48 matching lines @@
   Shell* shell = Shell::GetInstance();
   // If multi profile is not enabled we can use the normal index.
   if (!shell->delegate()->IsMultiProfilesEnabled())
     return multiprofile_index_;
   // In case of multi profile we need to mirror the indices since the system
   // tray items are in the reverse order then the menu items.
   return shell->session_state_delegate()->GetMaximumNumberOfLoggedInUsers() -
              1 - multiprofile_index_;
 }
 
-int TrayUser::GetTrayItemRadius() {
-  SessionStateDelegate* delegate =
-      Shell::GetInstance()->session_state_delegate();
-  bool is_last_item = GetTrayIndex() == (delegate->NumberOfLoggedInUsers() - 1);
-  return is_last_item ? kUserIconLargeCornerRadius : 0;
-}
-
 void TrayUser::UpdateLayoutOfItem() {
   internal::RootWindowController* controller =
       internal::GetRootWindowController(
           system_tray()->GetWidget()->GetNativeWindow()->GetRootWindow());
   if (controller && controller->shelf()) {
     UpdateAfterShelfAlignmentChange(
         controller->GetShelfLayoutManager()->GetAlignment());
   }
 }
 
 }  // namespace internal
 }  // namespace ash