Move non SystemTray specific code to TrayBackgroundView

ash/system/tray/tray_background_view.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/tray_background_view.h"
 
 #include "ash/launcher/background_animator.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/system/status_area_widget_delegate.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ui/aura/window.h"
+#include "ui/compositor/layer_animation_observer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/box_layout.h"
 
 namespace {
 
 const SkColor kTrayBackgroundAlpha = 100;
 const SkColor kTrayBackgroundHoverAlpha = 150;
 
 // Adjust the size of TrayContainer with additional padding.
 const int kTrayContainerVerticalPaddingBottomAlignment  = 1;
 const int kTrayContainerHorizontalPaddingBottomAlignment  = 1;
 const int kTrayContainerVerticalPaddingVerticalAlignment  = 1;
 const int kTrayContainerHorizontalPaddingVerticalAlignment = 1;
 
 }  // namespace
 
 namespace ash {
 namespace internal {
 
+// Observe the tray layer animation and update the anchor when it changes.
+// TODO(stevenjb): Observe or mirror the actual animation, not just the start
+// and end points.
+class TrayLayerAnimationObserver : public ui::LayerAnimationObserver {
+ public:
+  explicit TrayLayerAnimationObserver(TrayBackgroundView* host)
+      : host_(host) {
+  }
+
+  virtual void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) {
+    host_->AnchorUpdated();
+  }
+
+  virtual void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) {
+    host_->AnchorUpdated();
+  }
+
+  virtual void OnLayerAnimationScheduled(ui::LayerAnimationSequence* sequence) {
+    host_->AnchorUpdated();
+  }
+
+ private:
+  TrayBackgroundView* host_;
+
+  DISALLOW_COPY_AND_ASSIGN(TrayLayerAnimationObserver);
+};
+
 class TrayBackground : public views::Background {
  public:
   TrayBackground() : alpha_(kTrayBackgroundAlpha) {}
   virtual ~TrayBackground() {}
 
   void set_alpha(int alpha) { alpha_ = alpha; }
 
  private:
   // Overridden from views::Background.
   virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
@@ skipping 79 matching lines @@
 
 TrayBackgroundView::TrayBackgroundView(
     internal::StatusAreaWidget* status_area_widget)
     : status_area_widget_(status_area_widget),
       tray_container_(NULL),
       shelf_alignment_(SHELF_ALIGNMENT_BOTTOM),
       background_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(hide_background_animator_(
           this, 0, kTrayBackgroundAlpha)),
       ALLOW_THIS_IN_INITIALIZER_LIST(hover_background_animator_(
-          this, 0, kTrayBackgroundHoverAlpha - kTrayBackgroundAlpha)) {
+          this, 0, kTrayBackgroundHoverAlpha - kTrayBackgroundAlpha)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(layer_animation_observer_(
+          new TrayLayerAnimationObserver(this))) {
   set_notify_enter_exit_on_child(true);
 
   // Initially we want to paint the background, but without the hover effect.
   SetPaintsBackground(true, internal::BackgroundAnimator::CHANGE_IMMEDIATE);
   hover_background_animator_.SetPaintsBackground(false,
       internal::BackgroundAnimator::CHANGE_IMMEDIATE);
 
   tray_container_ = new TrayContainer(shelf_alignment_);
   SetContents(tray_container_);
 }
 
 TrayBackgroundView::~TrayBackgroundView() {
+  if (GetWidget()) {
+    GetWidget()->GetNativeView()->layer()->GetAnimator()->RemoveObserver(
+        layer_animation_observer_.get());
+  }
+}
+
+void TrayBackgroundView::Initialize() {
+  GetWidget()->GetNativeView()->layer()->GetAnimator()->AddObserver(
+      layer_animation_observer_.get());
+  SetBorder();
 }
 
 void TrayBackgroundView::OnMouseEntered(const ui::MouseEvent& event) {
   hover_background_animator_.SetPaintsBackground(true,
       internal::BackgroundAnimator::CHANGE_ANIMATE);
 }
 
 void TrayBackgroundView::OnMouseExited(const ui::MouseEvent& event) {
   hover_background_animator_.SetPaintsBackground(false,
       internal::BackgroundAnimator::CHANGE_ANIMATE);
 }
 
 void TrayBackgroundView::ChildPreferredSizeChanged(views::View* child) {
   PreferredSizeChanged();
 }
 
+void TrayBackgroundView::OnPaintFocusBorder(gfx::Canvas* canvas) {
+  // The tray itself expands to the right and bottom edge of the screen to make
+  // sure clicking on the edges brings up the popup. However, the focus border
+  // should be only around the container.
+  if (GetWidget() && GetWidget()->IsActive())
+    DrawBorder(canvas, GetContentsBounds());
+}
+
+void TrayBackgroundView::AboutToRequestFocusFromTabTraversal(bool reverse) {
+  // Return focus to the login view. See crbug.com/120500.
+  views::View* v = GetNextFocusableView();
+  if (v)
+    v->AboutToRequestFocusFromTabTraversal(reverse);
+}
+
 bool TrayBackgroundView::PerformAction(const ui::Event& event) {
   return false;
 }
 
 void TrayBackgroundView::UpdateBackground(int alpha) {
   if (background_) {
     background_->set_alpha(hide_background_animator_.alpha() +
                            hover_background_animator_.alpha());
   }
   SchedulePaint();
@@ skipping 37 matching lines @@
   } else {
     set_border(views::Border::CreateEmptyBorder(
         0, kPaddingFromInnerEdgeOfLauncherVerticalAlignment,
         on_edge ? kPaddingFromBottomOfScreenVerticalAlignment : 0,
         kPaddingFromOuterEdgeOfLauncherVerticalAlignment));
   }
 }
 
 }  // namespace internal
 }  // namespace ash