Fixes the mouse click of the search box in the home card.

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/home_card_impl.h"
 
 #include <cmath>
 #include <limits>
 
 #include "athena/env/public/athena_env.h"
 #include "athena/home/app_list_view_delegate.h"
 #include "athena/home/athena_start_page_view.h"
 #include "athena/home/home_card_constants.h"
 #include "athena/home/public/app_model_builder.h"
 #include "athena/screen/public/screen_manager.h"
 #include "athena/util/container_priorities.h"
 #include "athena/wm/public/window_manager.h"
 #include "ui/app_list/views/app_list_main_view.h"
 #include "ui/app_list/views/contents_view.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
+#include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/visibility_controller.h"
 
@@ skipping 92 matching lines @@
 class HomeCardView : public views::WidgetDelegateView,
                      public AthenaStartPageView::Observer {
  public:
   HomeCardView(app_list::AppListViewDelegate* view_delegate,
                aura::Window* container,
                HomeCardGestureManager::Delegate* gesture_delegate)
       : background_(new views::View),
         main_view_(new AthenaStartPageView(view_delegate)),
         minimized_background_(new views::View()),
         drag_indicator_(new views::View()),
-        gesture_delegate_(gesture_delegate) {
+        gesture_delegate_(gesture_delegate),
+        weak_factory_(this) {
     background_->set_background(
         views::Background::CreateVerticalGradientBackground(SK_ColorLTGRAY,
                                                             SK_ColorWHITE));
     background_->SetPaintToLayer(true);
     background_->SetFillsBoundsOpaquely(false);
     AddChildView(background_);
 
     // Ideally AppListMainView should be used here and have AthenaStartPageView
     // as its child view, so that custom pages and apps grid are available in
     // the home card.
     // TODO(mukai): make it so after the detailed UI has been fixed.
     main_view_->AddObserver(this);
     AddChildView(main_view_);
 
     minimized_background_->set_background(
         views::Background::CreateSolidBackground(
             SkColorSetA(SK_ColorBLACK, 256 * kMinimizedHomeOpacity)));
     minimized_background_->SetPaintToLayer(true);
     minimized_background_->SetFillsBoundsOpaquely(false);
     minimized_background_->layer()->set_name("MinimizedBackground");
     AddChildView(minimized_background_);

[yoshiki, 2014/11/04 06:49:29]

Just out of curiosity, why do you add the minimized background after the main
view? Doesn't just moving the minimized background before the mainview solve
this issue?

 
     drag_indicator_->set_background(
         views::Background::CreateSolidBackground(SK_ColorWHITE));
     drag_indicator_->SetPaintToLayer(true);
     AddChildView(drag_indicator_);
   }
 
   ~HomeCardView() override { main_view_->RemoveObserver(this); }
 
   void SetStateProgress(HomeCard::State from_state,
                         HomeCard::State to_state,
                         float progress) {
     // TODO(mukai): not clear the focus, but simply close the virtual keyboard.
     GetFocusManager()->ClearFocus();
     if (from_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(1.0f - progress);
     else if (to_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(progress);
 
     float background_opacity = 1.0f;
     if (from_state == HomeCard::VISIBLE_MINIMIZED ||
         to_state == HomeCard::VISIBLE_MINIMIZED) {
       background_opacity = (from_state == HomeCard::VISIBLE_MINIMIZED)
                                ? progress
                                : (1.0f - progress);
     }
     background_->layer()->SetOpacity(background_opacity);
     minimized_background_->layer()->SetOpacity(1.0f - background_opacity);
+    UpdateMinimizedBackgroundVisibility();
 
     int background_height = kHomeCardHeight;
     if (from_state == HomeCard::VISIBLE_CENTERED ||
         to_state == HomeCard::VISIBLE_CENTERED) {
       gfx::Rect window_bounds = GetWidget()->GetWindowBoundsInScreen();
       background_height = window_bounds.height() - window_bounds.y();
     }
     gfx::Transform background_transform;
     background_transform.Scale(
         SK_MScalar1,
         SkIntToMScalar(background_height) / SkIntToMScalar(height()));
     background_->layer()->SetTransform(background_transform);
 
     gfx::Rect from_bounds = GetDragIndicatorBounds(from_state);
     gfx::Rect to_bounds = GetDragIndicatorBounds(to_state);
     if (from_bounds != to_bounds) {
       DCHECK_EQ(from_bounds.size().ToString(), to_bounds.size().ToString());
       drag_indicator_->SetBoundsRect(
           gfx::Tween::RectValueBetween(progress, from_bounds, to_bounds));
     }
   }
 
   void SetStateWithAnimation(HomeCard::State state,
                              gfx::Tween::Type tween_type) {
     float minimized_opacity =
         (state == HomeCard::VISIBLE_MINIMIZED) ? 1.0f : 0.0f;
+    // |minimized_background_| needs to be visible before scheduling animation.
+    if (state == HomeCard::VISIBLE_MINIMIZED)
+      minimized_background_->SetVisible(true);
+
     if (minimized_opacity !=
         minimized_background_->layer()->GetTargetOpacity()) {
       ui::ScopedLayerAnimationSettings settings(
           minimized_background_->layer()->GetAnimator());
       settings.SetTweenType(gfx::Tween::EASE_IN);
+      settings.AddObserver(new ui::ClosureAnimationObserver(
+          base::Bind(&HomeCardView::UpdateMinimizedBackgroundVisibility,
+                     weak_factory_.GetWeakPtr())));
       minimized_background_->layer()->SetOpacity(minimized_opacity);
     }
 
     gfx::Transform background_transform;
     if (state != HomeCard::VISIBLE_CENTERED) {
       background_transform.Scale(
           SK_MScalar1,
           SkIntToMScalar(kHomeCardHeight) / SkIntToMScalar(height()));
     }
     float background_opacity = 1.0f - minimized_opacity;
@@ skipping 61 matching lines @@
   void Layout() override {
     gfx::Rect contents_bounds = GetContentsBounds();
     background_->SetBoundsRect(contents_bounds);
     main_view_->SetBoundsRect(contents_bounds);
     minimized_background_->SetBoundsRect(contents_bounds);
     drag_indicator_->SetBoundsRect(
         GetDragIndicatorBounds(HomeCard::Get()->GetState()));
   }
 
  private:
+  void UpdateMinimizedBackgroundVisibility() {
+    minimized_background_->SetVisible(
+        minimized_background_->layer()->GetTargetOpacity() != 0.0f);
+  }
+
   // views::WidgetDelegate:
   views::View* GetContentsView() override { return this; }
 
   // AthenaStartPageView::Observer:
   void OnLayoutStateChanged(float new_state) override {
     if (new_state == 1.0f)
       HomeCard::Get()->SetState(HomeCard::VISIBLE_CENTERED);
   }
 
   views::View* background_;
   AthenaStartPageView* main_view_;
   views::View* minimized_background_;
   views::View* drag_indicator_;
   HomeCard::State state_;
   scoped_ptr<HomeCardGestureManager> gesture_manager_;
   HomeCardGestureManager::Delegate* gesture_delegate_;
 
+  base::WeakPtrFactory<HomeCardView> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(HomeCardView);
 };
 
 HomeCardImpl::HomeCardImpl(scoped_ptr<AppModelBuilder> model_builder,
                            scoped_ptr<SearchControllerFactory> search_factory)
     : model_builder_(model_builder.Pass()),
       search_factory_(search_factory.Pass()),
       state_(HIDDEN),
       original_state_(VISIBLE_MINIMIZED),
       home_card_widget_(nullptr),
@@ skipping 179 matching lines @@
   instance = nullptr;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena