Fix focus loss on partial lock.

ui/compositor/layer_animator.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 "ui/compositor/layer_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/animation/animation_container.h"
@@ skipping 27 matching lines @@
 // Returns the AnimationContainer we're added to.
 ui::AnimationContainer* GetAnimationContainer() {
   static ui::AnimationContainer* container = NULL;
   if (!container) {
     container = new AnimationContainer();
     container->AddRef();
   }
   return container;
 }
 
+class SuccessCallbackAnimationObserver : public LayerAnimationObserver {
+ public:
+  SuccessCallbackAnimationObserver(base::Closure callback)
+      : callback_(callback),
+        num_attached_sequences_(0) {
+  }
+
+  virtual void OnLayerAnimationEnded(LayerAnimationSequence* sequence) {

[Daniel Erat, 2012/11/27 19:03:27]

nit: add OVERRIDE to all overridden methods, along with a comment like this
above them:

// LayerAnimationObserver overrides:

[Denis Kuznetsov (DE-MUC), 2012/11/28 15:41:46]

Done.

+    callback_.Run();
+    callback_.Reset();
+  }
+
+  virtual void OnLayerAnimationAborted(
+      LayerAnimationSequence* sequence) {}
+
+  virtual void OnLayerAnimationScheduled(
+      LayerAnimationSequence* sequence) {}
+
+ private:
+  virtual void OnAttachedToSequence(LayerAnimationSequence* sequence) {
+    num_attached_sequences_++;
+  }
+
+  virtual void OnDetachedFromSequence(LayerAnimationSequence* sequence) {
+    num_attached_sequences_--;
+    if (num_attached_sequences_ == 0)
+      delete this;
+  }
+
+  base::Closure callback_;
+  int num_attached_sequences_;
+
+  DISALLOW_COPY_AND_ASSIGN(SuccessCallbackAnimationObserver);
+};
+
 }  // namespace
 
 // static
 bool LayerAnimator::disable_animations_for_test_ = false;
 // static
 bool LayerAnimator::slow_animation_mode_ = false;
 // static
 int LayerAnimator::slow_animation_scale_factor_ = 4;
 
 // LayerAnimator public --------------------------------------------------------
@@ skipping 193 matching lines @@
   for (int p = static_cast<int>(property); p != -1; p = va_arg(marker, int)) {
     properties_to_pause.insert(
         static_cast<LayerAnimationElement::AnimatableProperty>(p));
   }
   va_end(marker);
   ScheduleAnimation(new ui::LayerAnimationSequence(
                         ui::LayerAnimationElement::CreatePauseElement(
                             properties_to_pause, duration)));
 }
 
+void LayerAnimator::SetCompletionCallbackForProperties(
+    base::Closure& callback,
+    LayerAnimationElement::AnimatableProperty property,
+    ...) {
+  ui::LayerAnimationElement::AnimatableProperties properties_to_pause;
+  va_list marker;
+  va_start(marker, property);
+  for (int p = static_cast<int>(property); p != -1; p = va_arg(marker, int)) {
+    properties_to_pause.insert(
+        static_cast<LayerAnimationElement::AnimatableProperty>(p));
+  }
+  va_end(marker);
+
+  ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
+      ui::LayerAnimationElement::CreatePauseElement(
+            properties_to_pause, base::TimeDelta()));
+
+  sequence->AddObserver(new SuccessCallbackAnimationObserver(callback));
+
+  ScheduleAnimation(sequence);
+}
+
 bool LayerAnimator::IsAnimatingProperty(
     LayerAnimationElement::AnimatableProperty property) const {
   for (AnimationQueue::const_iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
     if ((*queue_iter)->properties().find(property) !=
         (*queue_iter)->properties().end()) {
       return true;
     }
   }
   return false;
@@ skipping 262 matching lines @@
   const bool abort = false;
   RemoveAllAnimationsWithACommonProperty(sequence, abort);
   if (!weak_sequence_ptr)
     return;
 
   LayerAnimationSequence* removed = RemoveAnimation(sequence);
   DCHECK(removed == NULL || removed == sequence);
   if (!weak_sequence_ptr)
     return;
 
-  ProgressAnimation(sequence, sequence->duration());
+  ProgressAnimationToEnd(sequence);
   if (!weak_sequence_ptr)
     return;
 
   delete sequence;
 }
 
 void LayerAnimator::ImmediatelyAnimateToNewTarget(
     LayerAnimationSequence* sequence) {
   // Need to detect if our sequence gets destroyed.
   base::WeakPtr<LayerAnimationSequence> weak_sequence_ptr =
@@ skipping 195 matching lines @@
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence,
     base::TimeTicks start_time)
     : sequence_(sequence),
       start_time_(start_time) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui