Cleanup: remove HomeCardLayoutManager::Delegate.

athena/home/home_card_impl.cc

 // Copyright 2014 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 "athena/home/public/home_card.h"
 
 #include <cmath>
 #include <limits>
 
 #include "athena/common/container_priorities.h"
@@ skipping 54 matching lines @@
   }
 
   NOTREACHED();
   return gfx::Rect();
 }
 
 // Makes sure the homecard is center-aligned horizontally and bottom-aligned
 // vertically.
 class HomeCardLayoutManager : public aura::LayoutManager {
  public:
-  class Delegate {
-   public:
-    virtual ~Delegate() {}
-
-    virtual HomeCard::State GetState() = 0;
-    virtual aura::Window* GetNativeWindow() = 0;
-  };
-
-  explicit HomeCardLayoutManager(Delegate* delegate)
-      : delegate_(delegate) {}
+  explicit HomeCardLayoutManager()
+      : home_card_(NULL) {}
 
   virtual ~HomeCardLayoutManager() {}
 
   void Layout() {
-    aura::Window* home_card = delegate_->GetNativeWindow();
     // |home_card| could be detached from the root window (e.g. when it is being
     // destroyed).
-    if (!home_card || !home_card->GetRootWindow())
+    if (!home_card_ || !home_card_->IsVisible() || !home_card_->GetRootWindow())
       return;
 
     {
       ui::ScopedLayerAnimationSettings settings(
-          home_card->layer()->GetAnimator());
+          home_card_->layer()->GetAnimator());
       settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
-      SetChildBoundsDirect(home_card, GetBoundsForState(
-          home_card->GetRootWindow()->bounds(), delegate_->GetState()));
+      SetChildBoundsDirect(home_card_, GetBoundsForState(
+          home_card_->GetRootWindow()->bounds(), HomeCard::Get()->GetState()));
     }
   }
 
  private:
   // aura::LayoutManager:
   virtual void OnWindowResized() OVERRIDE { Layout(); }
-  virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE { Layout(); }
-  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
+  virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
+    if (!home_card_) {
+      home_card_ = child;
+      Layout();
+    }
+  }
+  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {
+    if (home_card_ == child)
+      home_card_ = NULL;
+  }
   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
     Layout();
   }
   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
                                               bool visible) OVERRIDE {
     Layout();
   }
   virtual void SetChildBounds(aura::Window* child,
                               const gfx::Rect& requested_bounds) OVERRIDE {
     SetChildBoundsDirect(child, requested_bounds);
   }
 
-  Delegate* delegate_;
+  aura::Window* home_card_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardLayoutManager);
 };
 
 class HomeCardGestureManager {
  public:
   class Delegate {
    public:
     // Called when the gesture has ended. The state of the home card will
     // end up with |final_state|.
@@ skipping 261 matching lines @@
   views::View* minimized_view_;
   scoped_ptr<HomeCardGestureManager> gesture_manager_;
   HomeCardGestureManager::Delegate* gesture_delegate_;
   base::WeakPtrFactory<HomeCardView> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardView);
 };
 
 class HomeCardImpl : public HomeCard,
                      public AcceleratorHandler,
-                     public HomeCardLayoutManager::Delegate,
                      public HomeCardGestureManager::Delegate,
                      public WindowManagerObserver,
                      public aura::client::ActivationChangeObserver {
  public:
   explicit HomeCardImpl(AppModelBuilder* model_builder);
   virtual ~HomeCardImpl();
 
   void Init();
 
  private:
   enum Command {
     COMMAND_SHOW_HOME_CARD,
   };
   void InstallAccelerators();
 
   // Overridden from HomeCard:
   virtual void SetState(State state) OVERRIDE;
   virtual State GetState() OVERRIDE;
   virtual void RegisterSearchProvider(
       app_list::SearchProvider* search_provider) OVERRIDE;
   virtual void UpdateVirtualKeyboardBounds(
       const gfx::Rect& bounds) OVERRIDE;
 
   // AcceleratorHandler:
   virtual bool IsCommandEnabled(int command_id) const OVERRIDE { return true; }
   virtual bool OnAcceleratorFired(int command_id,
                                   const ui::Accelerator& accelerator) OVERRIDE;
 
-  // HomeCardLayoutManager::Delegate:
-  virtual aura::Window* GetNativeWindow() OVERRIDE;
-
   // HomeCardGestureManager::Delegate:
   virtual void OnGestureEnded(State final_state) OVERRIDE;
   virtual void OnGestureProgressed(
       State from_state, State to_state, float progress) OVERRIDE;
 
   // WindowManagerObserver:
   virtual void OnOverviewModeEnter() OVERRIDE;
   virtual void OnOverviewModeExit() OVERRIDE;
 
   // aura::client::ActivationChangeObserver:
@@ skipping 46 matching lines @@
   view_delegate_.reset();
   search_provider_.reset();
   instance = NULL;
 }
 
 void HomeCardImpl::Init() {
   InstallAccelerators();
   ScreenManager::ContainerParams params("HomeCardContainer", CP_HOME_CARD);
   params.can_activate_children = true;
   aura::Window* container = ScreenManager::Get()->CreateContainer(params);
-  layout_manager_ = new HomeCardLayoutManager(this);
+  layout_manager_ = new HomeCardLayoutManager();
 
   container->SetLayoutManager(layout_manager_);
   wm::SetChildWindowVisibilityChangesAnimated(container);
 
   view_delegate_.reset(new AppListViewDelegate(model_builder_.get()));
   if (search_provider_)
     view_delegate_->RegisterSearchProvider(search_provider_.get());
 
   home_card_view_ = new HomeCardView(view_delegate_.get(), container, this);
   home_card_widget_ = new views::Widget();
   views::Widget::InitParams widget_params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   widget_params.parent = container;
   widget_params.delegate = home_card_view_;
   widget_params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   home_card_widget_->Init(widget_params);
 
   SetState(VISIBLE_MINIMIZED);
   home_card_view_->Layout();
 
   activation_client_ =
       aura::client::GetActivationClient(container->GetRootWindow());
   if (activation_client_)
     activation_client_->AddObserver(this);
 
   int work_area_bottom_inset =
-      GetBoundsForState(GetNativeWindow()->bounds(),
+      GetBoundsForState(home_card_widget_->GetNativeWindow()->bounds(),
                         HomeCard::VISIBLE_MINIMIZED).height();
   AthenaEnv::Get()->SetDisplayWorkAreaInsets(
       gfx::Insets(0, 0, work_area_bottom_inset, 0));
 }
 
 void HomeCardImpl::InstallAccelerators() {
   const AcceleratorData accelerator_data[] = {
       {TRIGGER_ON_PRESS, ui::VKEY_L, ui::EF_CONTROL_DOWN,
        COMMAND_SHOW_HOME_CARD, AF_NONE},
   };
@@ skipping 50 matching lines @@
                                       const ui::Accelerator& accelerator) {
   DCHECK_EQ(COMMAND_SHOW_HOME_CARD, command_id);
 
   if (state_ == VISIBLE_CENTERED && original_state_ != VISIBLE_BOTTOM)
     SetState(VISIBLE_MINIMIZED);
   else if (state_ == VISIBLE_MINIMIZED)
     SetState(VISIBLE_CENTERED);
   return true;
 }
 
-aura::Window* HomeCardImpl::GetNativeWindow() {
-  if (state_ == HIDDEN)
-    return NULL;
-
-  return home_card_widget_ ? home_card_widget_->GetNativeWindow() : NULL;
-}
-
 void HomeCardImpl::OnGestureEnded(State final_state) {
   home_card_view_->ClearGesture();
   if (state_ != final_state &&
       (state_ == VISIBLE_MINIMIZED || final_state == VISIBLE_MINIMIZED)) {
     WindowManager::GetInstance()->ToggleOverview();
   } else {
     HomeCard::State old_state = state_;
     state_ = final_state;
     home_card_view_->SetStateWithAnimation(old_state, final_state);
     layout_manager_->Layout();
@@ skipping 47 matching lines @@
   instance = NULL;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena