Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/tabs/tab_utils.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/ui/tabs/tab_utils.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/strings/string16.h"
@@ skipping 49 matching lines @@
 
 // Animation that throbs in (towards 1.0) and out (towards 0.0), and ends in the
 // "in" state.
 class TabRecordingIndicatorAnimation : public gfx::MultiAnimation {
  public:
   ~TabRecordingIndicatorAnimation() override {}
 
   // Overridden to provide alternating "towards in" and "towards out" behavior.
   double GetCurrentValue() const override;
 
-  static scoped_ptr<TabRecordingIndicatorAnimation> Create();
+  static std::unique_ptr<TabRecordingIndicatorAnimation> Create();
 
  private:
   TabRecordingIndicatorAnimation(const gfx::MultiAnimation::Parts& parts,
                                  const base::TimeDelta interval)
       : MultiAnimation(parts, interval) {}
 
   // Number of times to "toggle throb" the recording and tab capture indicators
   // when they first appear.
   static const int kCaptureIndicatorThrobCycles = 5;
 };
 
 double TabRecordingIndicatorAnimation::GetCurrentValue() const {
   return current_part_index() % 2 ?
       1.0 - MultiAnimation::GetCurrentValue() :
       MultiAnimation::GetCurrentValue();
 }
 
-scoped_ptr<TabRecordingIndicatorAnimation>
+std::unique_ptr<TabRecordingIndicatorAnimation>
 TabRecordingIndicatorAnimation::Create() {
   MultiAnimation::Parts parts;
   static_assert(kCaptureIndicatorThrobCycles % 2 != 0,
         "odd number of cycles required so animation finishes in showing state");
   for (int i = 0; i < kCaptureIndicatorThrobCycles; ++i) {
     parts.push_back(MultiAnimation::Part(
         i % 2 ? kIndicatorFadeOutDurationMs : kIndicatorFadeInDurationMs,
         gfx::Tween::EASE_IN));
   }
   const base::TimeDelta interval =
       base::TimeDelta::FromMilliseconds(kIndicatorFrameIntervalMs);
-  scoped_ptr<TabRecordingIndicatorAnimation> animation(
+  std::unique_ptr<TabRecordingIndicatorAnimation> animation(
       new TabRecordingIndicatorAnimation(parts, interval));
   animation->set_continuous(false);
   return animation;
 }
 
 }  // namespace
 
 bool ShouldTabShowFavicon(int capacity,
                           bool is_pinned_tab,
                           bool is_active_tab,
@@ skipping 115 matching lines @@
     case TabAlertState::NONE:
     case TabAlertState::MEDIA_RECORDING:
     case TabAlertState::TAB_CAPTURING:
     case TabAlertState::BLUETOOTH_CONNECTED:
       return GetTabAlertIndicatorImage(alert_state, button_color);
   }
   NOTREACHED();
   return GetTabAlertIndicatorImage(alert_state, button_color);
 }
 
-scoped_ptr<gfx::Animation> CreateTabAlertIndicatorFadeAnimation(
+std::unique_ptr<gfx::Animation> CreateTabAlertIndicatorFadeAnimation(
     TabAlertState alert_state) {
   if (alert_state == TabAlertState::MEDIA_RECORDING ||
       alert_state == TabAlertState::TAB_CAPTURING) {
     return TabRecordingIndicatorAnimation::Create();
   }
 
   // Note: While it seems silly to use a one-part MultiAnimation, it's the only
   // gfx::Animation implementation that lets us control the frame interval.
   gfx::MultiAnimation::Parts parts;
   const bool is_for_fade_in = (alert_state != TabAlertState::NONE);
   parts.push_back(gfx::MultiAnimation::Part(
       is_for_fade_in ? kIndicatorFadeInDurationMs : kIndicatorFadeOutDurationMs,
       gfx::Tween::EASE_IN));
   const base::TimeDelta interval =
       base::TimeDelta::FromMilliseconds(kIndicatorFrameIntervalMs);
-  scoped_ptr<gfx::MultiAnimation> animation(
+  std::unique_ptr<gfx::MultiAnimation> animation(
       new gfx::MultiAnimation(parts, interval));
   animation->set_continuous(false);
   return std::move(animation);
 }
 
 base::string16 AssembleTabTooltipText(const base::string16& title,
                                       TabAlertState alert_state) {
   if (alert_state == TabAlertState::NONE)
     return title;
 
@@ skipping 112 matching lines @@
                      const std::vector<int>& indices) {
   for (std::vector<int>::const_iterator i = indices.begin(); i != indices.end();
        ++i) {
     if (!tab_strip.GetWebContentsAt(*i)->IsAudioMuted())
       return false;
   }
   return true;
 }
 
 }  // namespace chrome