Fix VK animation related issues

chrome/browser/ui/ash/ash_keyboard_controller_proxy.cc

 // Copyright (c) 2013 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 "chrome/browser/ui/ash/ash_keyboard_controller_proxy.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/shell.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
@@ skipping 23 matching lines @@
 namespace virtual_keyboard_private = extensions::api::virtual_keyboard_private;
 typedef virtual_keyboard_private::OnTextInputBoxFocused::Context Context;
 
 namespace {
 
 const char* kVirtualKeyboardExtensionID = "mppnpdlheglhdfmldimlhpnegondlapf";
 
 // The virtual keyboard show/hide animation duration.
 const int kAnimationDurationMs = 200;
 
+// The opacity of virtual keyboard container when show animation starts or
+// hide animation finishes.
+const float kAnimationStartOrAfterHideOpacity = 0.2f;
+
 Context::Type TextInputTypeToGeneratedInputTypeEnum(ui::TextInputType type) {
   switch (type) {
     case ui::TEXT_INPUT_TYPE_NONE:
       return Context::TYPE_NONE;
     case ui::TEXT_INPUT_TYPE_PASSWORD:
       return Context::TYPE_PASSWORD;
     case ui::TEXT_INPUT_TYPE_EMAIL:
       return Context::TYPE_EMAIL;
     case ui::TEXT_INPUT_TYPE_NUMBER:
       return Context::TYPE_NUMBER;
@@ skipping 97 matching lines @@
   if (container->GetRootWindow() != ash::Shell::GetPrimaryRootWindow())
     NOTIMPLEMENTED();
 
   ui::LayerAnimator* container_animator = container->layer()->GetAnimator();
   // If the container is not animating, makes sure the position and opacity
   // are at begin states for animation.
   if (!container_animator->is_animating()) {
     gfx::Transform transform;
     transform.Translate(0, GetKeyboardWindow()->bounds().height());
     container->SetTransform(transform);
-    container->layer()->SetOpacity(0.0);
+    container->layer()->SetOpacity(kAnimationStartOrAfterHideOpacity);
   }
 
+  container_animator->set_preemption_strategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+
   {
     // Scope the following animation settings as we don't want to animate
     // visibility change that triggered by a call to the base class function
     // ShowKeyboardContainer with these settings. The container should become
     // visible immediately.
     ui::ScopedLayerAnimationSettings settings(container_animator);
-    settings.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     settings.SetTweenType(gfx::Tween::EASE_IN);
     settings.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kAnimationDurationMs));
     container->SetTransform(gfx::Transform());
     container->layer()->SetOpacity(1.0);
   }
 
   // TODO(bshe): Add animation observer and do the workspace resizing after
   // animation finished.
   KeyboardControllerProxy::ShowKeyboardContainer(container);
   // GetTextInputClient may return NULL when keyboard-usability-experiment flag
   // is set.
   if (GetInputMethod()->GetTextInputClient()) {
     gfx::Rect showing_area =
         ash::DisplayController::GetPrimaryDisplay().work_area();
     GetInputMethod()->GetTextInputClient()->EnsureCaretInRect(showing_area);
   }
 }
 
 void AshKeyboardControllerProxy::HideKeyboardContainer(
     aura::Window* container) {
   // The following animation settings should persist within this function scope.
   // Otherwise, a call to base class function HideKeyboardContainer will hide
   // the container immediately.
   ui::LayerAnimator* container_animator = container->layer()->GetAnimator();
   container_animator->AddObserver(this);
   animation_window_ = container;
   ui::ScopedLayerAnimationSettings settings(container_animator);
-  settings.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTweenType(gfx::Tween::EASE_OUT);
   settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kAnimationDurationMs));
   gfx::Transform transform;
   transform.Translate(0, GetKeyboardWindow()->bounds().height());
   container->SetTransform(transform);
-  container->layer()->SetOpacity(0.0);
+  container->layer()->SetOpacity(kAnimationStartOrAfterHideOpacity);
 }
 
 void AshKeyboardControllerProxy::OnLayerAnimationEnded(
     ui::LayerAnimationSequence* sequence) {
   if (!animation_window_)
     return;
   ui::LayerAnimator* animator = animation_window_->layer()->GetAnimator();
-  if (animator && !animator->is_animating()) {
+  if (!animator->is_animating()) {
     KeyboardControllerProxy::HideKeyboardContainer(animation_window_);
     animator->RemoveObserver(this);

[James Cook, 2014/01/16 17:55:03]

Is it possible to leak this observer?  I'm not clear on what happens if
OnLayerAnimationEnded() is called but this if() branch isn't taken.

[bshe, 2014/01/16 20:09:04]

We have a few animations at the same time. So OnLayerAnimationEnded may called
multiple times. And we only want to remove the observer if the last animation
finished, hence the if() branch. If the remaining animation is somehow aborted,
the observer should be removed in the OnLayerAnimationAborted below. So it
should be safe.

On 2014/01/16 17:55:03, James Cook wrote:

     animation_window_ = NULL;
   }
 };
 
 void AshKeyboardControllerProxy::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* sequence) {
   if (!animation_window_)
     return;
-  ui::LayerAnimator* animator = animation_window_->layer()->GetAnimator();
-  if (animator) {
-    animator->RemoveObserver(this);
-  }
+  animation_window_->layer()->GetAnimator()->RemoveObserver(this);
   animation_window_ = NULL;
 };
 
 void AshKeyboardControllerProxy::SetUpdateInputType(ui::TextInputType type) {
   // TODO(bshe): Need to check the affected window's profile once multi-profile
   // is supported.
   content::BrowserContext* context = GetBrowserContext();
   extensions::EventRouter* router =
       extensions::ExtensionSystem::GetForBrowserContext(context)->
       event_router();
 
   if (!router->HasEventListener(
           virtual_keyboard_private::OnTextInputBoxFocused::kEventName)) {
     return;
   }
 
   scoped_ptr<base::ListValue> event_args(new base::ListValue());
   scoped_ptr<base::DictionaryValue> input_context(new base::DictionaryValue());
   input_context->SetString("type",
       Context::ToString(TextInputTypeToGeneratedInputTypeEnum(type)));
   event_args->Append(input_context.release());
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       virtual_keyboard_private::OnTextInputBoxFocused::kEventName,
       event_args.Pass()));
   event->restrict_to_browser_context = context;
   router->DispatchEventToExtension(kVirtualKeyboardExtensionID, event.Pass());
 }