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);
+  // Must hide keyboard container here instead of when animation finished or
+  // aborted. Otherwise, if we regain focus during hide animation, show
+  // animation wont be triggered because Chrome still thinks the keyboard
+  // container is visible and ignores show keyboard request.
+  container->Hide();
+  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()) {
-    KeyboardControllerProxy::HideKeyboardContainer(animation_window_);
+    // Hides keyboard window after keyboard window container's animation
+    // finished. Otherwise, keyboard window hides immediately and makes it looks
+    // like no animation at all.
+    GetKeyboardWindow()->Hide();

[James Cook, 2014/01/15 20:49:57]

I'm having a hard time following this and the Hide() call above. Is it really
necessary to have both the keyboard container and the keyboard window being
individually shown and hidden at different times?  Does it have to be this way,
or is there some way to have a single visibility switch?

[bshe, 2014/01/16 17:47:58]

Looks like it is possible if I add a check condition in the keyboard_controller.
Please see the latest patch.

On 2014/01/15 20:49:57, James Cook wrote:

     animator->RemoveObserver(this);
     animation_window_ = NULL;
   }
 };
 
 void AshKeyboardControllerProxy::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* sequence) {
   if (!animation_window_)
     return;
   ui::LayerAnimator* animator = animation_window_->layer()->GetAnimator();
@@ skipping 21 matching lines @@
   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());
 }