Update chrome/ to use WeakPtr<T>::get() instead of implicit "operator T*"

chrome/browser/extensions/extension_action.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 "chrome/browser/extensions/extension_action.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 52 matching lines @@
       base::WeakPtr<ExtensionAction::IconAnimation> animation)
       : image_(image),
         animation_(animation) {
   }
 
  private:
   virtual ~AnimatedIconImageSource() {}
 
   virtual gfx::ImageSkiaRep GetImageForScale(ui::ScaleFactor scale) OVERRIDE {
     gfx::ImageSkiaRep original_rep = image_.GetRepresentation(scale);
-    if (!animation_)
+    if (!animation_.get())
       return original_rep;
 
     // Original representation's scale factor may be different from scale
     // factor passed to this method. We want to use the former (since we are
     // using bitmap for that scale).
     return gfx::ImageSkiaRep(
         animation_->Apply(original_rep.sk_bitmap()),
         original_rep.scale_factor());
   }
 
@@ skipping 58 matching lines @@
 
 void ExtensionAction::IconAnimation::AnimateToState(double state) {
   FOR_EACH_OBSERVER(Observer, observers_, OnIconChanged());
 }
 
 ExtensionAction::IconAnimation::ScopedObserver::ScopedObserver(
     const base::WeakPtr<IconAnimation>& icon_animation,
     Observer* observer)
     : icon_animation_(icon_animation),
       observer_(observer) {
-  if (icon_animation)
+  if (icon_animation.get())
     icon_animation->AddObserver(observer);
 }
 
 ExtensionAction::IconAnimation::ScopedObserver::~ScopedObserver() {
-  if (icon_animation_)
+  if (icon_animation_.get())
     icon_animation_->RemoveObserver(observer_);
 }
 
 ExtensionAction::ExtensionAction(
     const std::string& extension_id,
     extensions::ActionInfo::Type action_type,
     const extensions::ActionInfo& manifest_data)
     : extension_id_(extension_id),
       action_type_(action_type),
       has_changed_(false) {
@@ skipping 179 matching lines @@
   return ui::ResourceBundle::GetSharedInstance().GetImageNamed(
           IDR_EXTENSIONS_FAVICON).ToImageSkia()->width();
 }
 
 base::WeakPtr<ExtensionAction::IconAnimation> ExtensionAction::GetIconAnimation(
     int tab_id) const {
   std::map<int, base::WeakPtr<IconAnimation> >::iterator it =
       icon_animation_.find(tab_id);
   if (it == icon_animation_.end())
     return base::WeakPtr<ExtensionAction::IconAnimation>();
-  if (it->second)
+  if (it->second.get())
     return it->second;
 
   // Take this opportunity to remove all the NULL IconAnimations from
   // icon_animation_.
   icon_animation_.erase(it);
   for (it = icon_animation_.begin(); it != icon_animation_.end();) {
-    if (it->second) {
+    if (it->second.get()) {
       ++it;
     } else {
       // The WeakPtr is null; remove it from the map.
       icon_animation_.erase(it++);
     }
   }
   return base::WeakPtr<ExtensionAction::IconAnimation>();
 }
 
 gfx::ImageSkia ExtensionAction::ApplyIconAnimation(
     int tab_id,
     const gfx::ImageSkia& icon) const {
   base::WeakPtr<IconAnimation> animation = GetIconAnimation(tab_id);
-  if (animation == NULL)
+  if (animation.get() == NULL)
     return icon;
 
   return gfx::ImageSkia(new AnimatedIconImageSource(icon, animation),
                         icon.size());
 }
 
 namespace {
 // Used to create a Callback owning an IconAnimation.
 void DestroyIconAnimation(scoped_ptr<ExtensionAction::IconAnimation>) {}
 }
 void ExtensionAction::RunIconAnimation(int tab_id) {
   scoped_ptr<IconAnimation> icon_animation(new IconAnimation());
   icon_animation_[tab_id] = icon_animation->AsWeakPtr();
   icon_animation->Start();
   // After the icon is finished fading in (plus some padding to handle random
   // timer delays), destroy it. We use a delayed task so that the Animation is
   // deleted even if it hasn't finished by the time the MessageLoop is
   // destroyed.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&DestroyIconAnimation, base::Passed(&icon_animation)),
       base::TimeDelta::FromMilliseconds(kIconFadeInDurationMs * 2));
 }