Update remaining files to use WeakPtr<T>::get() instead of "operator T*"

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 "cc/animation/animation_id_provider.h"
@@ skipping 583 matching lines @@
   }
 
   // Same for the queued animations that haven't been started. Again, we'll
   // need to operate on a copy.
   std::vector<base::WeakPtr<LayerAnimationSequence> > sequences;
   for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter)
     sequences.push_back((*queue_iter)->AsWeakPtr());
 
   for (size_t i = 0; i < sequences.size(); ++i) {
-    if (!sequences[i] || !HasAnimation(sequences[i]))
+    if (!sequences[i].get() || !HasAnimation(sequences[i].get()))
       continue;
 
     if (sequences[i]->HasConflictingProperty(sequence->properties())) {
-      scoped_ptr<LayerAnimationSequence> removed(RemoveAnimation(sequences[i]));
+      scoped_ptr<LayerAnimationSequence> removed(
+          RemoveAnimation(sequences[i].get()));
       if (abort)
         sequences[i]->Abort(delegate());
       else
-        ProgressAnimationToEnd(sequences[i]);
+        ProgressAnimationToEnd(sequences[i].get());
     }
   }
 }
 
 void LayerAnimator::ImmediatelySetNewTarget(LayerAnimationSequence* sequence) {
   // Need to detect if our sequence gets destroyed.
   base::WeakPtr<LayerAnimationSequence> weak_sequence_ptr =
       sequence->AsWeakPtr();
 
   const bool abort = false;
   RemoveAllAnimationsWithACommonProperty(sequence, abort);
-  if (!weak_sequence_ptr)
+  if (!weak_sequence_ptr.get())
     return;
 
   LayerAnimationSequence* removed = RemoveAnimation(sequence);
   DCHECK(removed == NULL || removed == sequence);
-  if (!weak_sequence_ptr)
+  if (!weak_sequence_ptr.get())
     return;
 
   ProgressAnimationToEnd(sequence);
-  if (!weak_sequence_ptr)
+  if (!weak_sequence_ptr.get())
     return;
 
   delete sequence;
 }
 
 void LayerAnimator::ImmediatelyAnimateToNewTarget(
     LayerAnimationSequence* sequence) {
   // Need to detect if our sequence gets destroyed.
   base::WeakPtr<LayerAnimationSequence> weak_sequence_ptr =
       sequence->AsWeakPtr();
 
   const bool abort = true;
   RemoveAllAnimationsWithACommonProperty(sequence, abort);
-  if (!weak_sequence_ptr)
+  if (!weak_sequence_ptr.get())
     return;
 
   AddToQueueIfNotPresent(sequence);
-  if (!weak_sequence_ptr)
+  if (!weak_sequence_ptr.get())
     return;
 
   StartSequenceImmediately(sequence);
 }
 
 void LayerAnimator::EnqueueNewAnimation(LayerAnimationSequence* sequence) {
   // It is assumed that if there was no conflicting animation, we would
   // not have been called. No need to check for a collision; just
   // add to the queue.
   animation_queue_.push_back(make_linked_ptr(sequence));
   ProcessQueue();
 }
 
 void LayerAnimator::ReplaceQueuedAnimations(LayerAnimationSequence* sequence) {
   // Need to detect if our sequence gets destroyed.
   base::WeakPtr<LayerAnimationSequence> weak_sequence_ptr =
       sequence->AsWeakPtr();
 
   // Remove all animations that aren't running. Note: at each iteration i is
   // incremented or an element is removed from the queue, so
   // animation_queue_.size() - i is always decreasing and we are always making
   // progress towards the loop terminating.
   for (size_t i = 0; i < animation_queue_.size();) {
-    if (!weak_sequence_ptr)
+    if (!weak_sequence_ptr.get())
       break;
 
     PurgeDeletedAnimations();
 
     bool is_running = false;
     for (RunningAnimations::const_iterator iter = running_animations_.begin();
          iter != running_animations_.end(); ++iter) {
       if ((*iter).sequence() == animation_queue_[i].get()) {
         is_running = true;
         break;
@@ skipping 26 matching lines @@
     // Try to find an animation that doesn't conflict with an animated
     // property or a property that will be animated before it. Note: starting
     // the animation may indirectly cause more animations to be started, so we
     // need to operate on a copy.
     std::vector<base::WeakPtr<LayerAnimationSequence> > sequences;
     for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
          queue_iter != animation_queue_.end(); ++queue_iter)
       sequences.push_back((*queue_iter)->AsWeakPtr());
 
     for (size_t i = 0; i < sequences.size(); ++i) {
-      if (!sequences[i] || !HasAnimation(sequences[i]))
+      if (!sequences[i].get() || !HasAnimation(sequences[i].get()))
         continue;
 
       if (!sequences[i]->HasConflictingProperty(animated)) {
         StartSequenceImmediately(sequences[i].get());
         started_sequence = true;
         break;
       }
 
       // Animation couldn't be started. Add its properties to the collection so
       // that we don't start a conflicting animation. For example, if our queue
@@ skipping 110 matching lines @@
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui