Converts Widget::SetOpacity from char to float

chrome/browser/ui/views/status_bubble_views.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/views/status_bubble_views.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
@@ skipping 68 matching lines @@
 // How long each expansion step should take.
 static const int kMinExpansionStepDurationMS = 20;
 static const int kMaxExpansionStepDurationMS = 150;
 
 
 // StatusBubbleViews::StatusViewAnimation --------------------------------------
 class StatusBubbleViews::StatusViewAnimation : public gfx::LinearAnimation,
                                                public gfx::AnimationDelegate {
  public:
   StatusViewAnimation(StatusView* status_view,
-                      double opacity_start,
-                      double opacity_end);
+                      float opacity_start,
+                      float opacity_end);
   ~StatusViewAnimation() override;
 
-  double GetCurrentOpacity();
+  float GetCurrentOpacity();
 
  private:
   // gfx::LinearAnimation:
   void AnimateToState(double state) override;
 
   // gfx::AnimationDelegate:
   void AnimationEnded(const Animation* animation) override;
 
   StatusView* status_view_;
 
   // Start and end opacities for the current transition - note that as a
   // fade-in can easily turn into a fade out, opacity_start_ is sometimes
   // a value between 0 and 1.
-  double opacity_start_;
-  double opacity_end_;
+  float opacity_start_;
+  float opacity_end_;
 
   DISALLOW_COPY_AND_ASSIGN(StatusViewAnimation);
 };
 
 
 // StatusBubbleViews::StatusView -----------------------------------------------
 //
 // StatusView manages the display of the bubble, applying text changes and
 // fading in or out the bubble as required.
 class StatusBubbleViews::StatusView : public views::View {
@@ skipping 32 matching lines @@
   void Show();
 
   // Hide the bubble instantly.
   void Hide();
 
   // Resets any timers we have. Typically called when the user moves a
   // mouse.
   void ResetTimer();
 
   // This call backs the StatusView in order to fade the bubble in and out.
-  void SetOpacity(double opacity);
+  void SetOpacity(float opacity);
 
   // Depending on the state of the bubble this will either hide the popup or
   // not.
   void OnAnimationEnded();
 
  private:
   class InitialTimer;
 
   // Manage the timers that control the delay before a fade begins or ends.
   void StartTimer(base::TimeDelta time);
   void OnTimer();
   void CancelTimer();
   void RestartTimer(base::TimeDelta delay);
 
   // Manage the fades and starting and stopping the animations correctly.
-  void StartFade(double start, double end, int duration);
+  void StartFade(float start, float end, int duration);
   void StartHiding();
   void StartShowing();
 
   // views::View:
   const char* GetClassName() const override;
   void OnPaint(gfx::Canvas* canvas) override;
 
   BubbleState state_;
   BubbleStyle style_;
 
@@ skipping 67 matching lines @@
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&StatusBubbleViews::StatusView::OnTimer,
                             timer_factory_.GetWeakPtr()),
       time);
 }
 
 void StatusBubbleViews::StatusView::OnTimer() {
   if (state_ == BUBBLE_HIDING_TIMER) {
     state_ = BUBBLE_HIDING_FADE;
-    StartFade(1.0, 0.0, kHideFadeDurationMS);
+    StartFade(1.0f, 0.0f, kHideFadeDurationMS);
   } else if (state_ == BUBBLE_SHOWING_TIMER) {
     state_ = BUBBLE_SHOWING_FADE;
-    StartFade(0.0, 1.0, kShowFadeDurationMS);
+    StartFade(0.0f, 1.0f, kShowFadeDurationMS);
   }
 }
 
 void StatusBubbleViews::StatusView::CancelTimer() {
   if (timer_factory_.HasWeakPtrs())
     timer_factory_.InvalidateWeakPtrs();
 }
 
 void StatusBubbleViews::StatusView::RestartTimer(base::TimeDelta delay) {
   CancelTimer();
   StartTimer(delay);
 }
 
 void StatusBubbleViews::StatusView::ResetTimer() {
   if (state_ == BUBBLE_SHOWING_TIMER) {
     // We hadn't yet begun showing anything when we received a new request
     // for something to show, so we start from scratch.
     RestartTimer(base::TimeDelta::FromMilliseconds(kShowDelay));
   }
 }
 
-void StatusBubbleViews::StatusView::StartFade(double start,
-                                              double end,
+void StatusBubbleViews::StatusView::StartFade(float start,
+                                              float end,
                                               int duration) {
   animation_.reset(new StatusViewAnimation(this, start, end));
 
   // This will also reset the currently-occurring animation.
   animation_->SetDuration(duration);
   animation_->Start();
 }
 
 void StatusBubbleViews::StatusView::StartHiding() {
   if (state_ == BUBBLE_SHOWN) {
     state_ = BUBBLE_HIDING_TIMER;
     StartTimer(base::TimeDelta::FromMilliseconds(kHideDelay));
   } else if (state_ == BUBBLE_SHOWING_TIMER) {
     state_ = BUBBLE_HIDDEN;
     popup_->Hide();
     CancelTimer();
   } else if (state_ == BUBBLE_SHOWING_FADE) {
     state_ = BUBBLE_HIDING_FADE;
     // Figure out where we are in the current fade.
-    double current_opacity = animation_->GetCurrentOpacity();
+    float current_opacity = animation_->GetCurrentOpacity();
 
     // Start a fade in the opposite direction.
-    StartFade(current_opacity, 0.0,
+    StartFade(current_opacity, 0.0f,
               static_cast<int>(kHideFadeDurationMS * current_opacity));
   }
 }
 
 void StatusBubbleViews::StatusView::StartShowing() {
   if (state_ == BUBBLE_HIDDEN) {
     popup_->ShowInactive();
     state_ = BUBBLE_SHOWING_TIMER;
     StartTimer(base::TimeDelta::FromMilliseconds(kShowDelay));
   } else if (state_ == BUBBLE_HIDING_TIMER) {
     state_ = BUBBLE_SHOWN;
     CancelTimer();
   } else if (state_ == BUBBLE_HIDING_FADE) {
     // We're partway through a fade.
     state_ = BUBBLE_SHOWING_FADE;
 
     // Figure out where we are in the current fade.
-    double current_opacity = animation_->GetCurrentOpacity();
+    float current_opacity = animation_->GetCurrentOpacity();
 
     // Start a fade in the opposite direction.
-    StartFade(current_opacity, 1.0,
+    StartFade(current_opacity, 1.0f,
               static_cast<int>(kShowFadeDurationMS * current_opacity));
   } else if (state_ == BUBBLE_SHOWING_TIMER) {
     // We hadn't yet begun showing anything when we received a new request
     // for something to show, so we start from scratch.
     ResetTimer();
   }
 }
 
-void StatusBubbleViews::StatusView::SetOpacity(double opacity) {
-  popup_->SetOpacity(static_cast<unsigned char>(opacity * 255));
+void StatusBubbleViews::StatusView::SetOpacity(float opacity) {
+  popup_->SetOpacity(opacity);
 }
 
 void StatusBubbleViews::StatusView::SetStyle(BubbleStyle style) {
   if (style_ != style) {
     style_ = style;
     SchedulePaint();
   }
 }
 
 void StatusBubbleViews::StatusView::OnAnimationEnded() {
@@ skipping 90 matching lines @@
   canvas->DrawStringRect(text_, font_list,
                          SkColorSetA(text_color, SkColorGetA(text_color) / 2),
                          text_bounds);
 }
 
 
 // StatusBubbleViews::StatusViewAnimation --------------------------------------
 
 StatusBubbleViews::StatusViewAnimation::StatusViewAnimation(
     StatusView* status_view,
-    double opacity_start,
-    double opacity_end)
+    float opacity_start,
+    float opacity_end)
     : gfx::LinearAnimation(kFramerate, this),
       status_view_(status_view),
       opacity_start_(opacity_start),
-      opacity_end_(opacity_end) {
-}
+      opacity_end_(opacity_end) {}
 
 StatusBubbleViews::StatusViewAnimation::~StatusViewAnimation() {
   // Remove ourself as a delegate so that we don't get notified when
   // animations end as a result of destruction.
   set_delegate(NULL);
 }
 
-double StatusBubbleViews::StatusViewAnimation::GetCurrentOpacity() {
-  return opacity_start_ + (opacity_end_ - opacity_start_) *
-      gfx::LinearAnimation::GetCurrentValue();
+float StatusBubbleViews::StatusViewAnimation::GetCurrentOpacity() {
+  return static_cast<float>(opacity_start_ +
+                            (opacity_end_ - opacity_start_) *
+                                gfx::LinearAnimation::GetCurrentValue());
 }
 
 void StatusBubbleViews::StatusViewAnimation::AnimateToState(double state) {
   status_view_->SetOpacity(GetCurrentOpacity());
 }
 
 void StatusBubbleViews::StatusViewAnimation::AnimationEnded(
     const gfx::Animation* animation) {
   status_view_->SetOpacity(opacity_end_);
   status_view_->OnAnimationEnded();
@@ skipping 124 matching lines @@
     params.parent = frame->GetNativeView();
     params.context = frame->GetNativeWindow();
 #if defined(MOJO_SHELL_CLIENT)
     params.mus_properties
         [mus::mojom::WindowManager::kWindowIgnoredByShelf_Property] =
         mojo::ConvertTo<std::vector<uint8_t>>(true);
 #endif
     popup_->Init(params);
     // We do our own animation and don't want any from the system.
     popup_->SetVisibilityChangedAnimationsEnabled(false);
-    popup_->SetOpacity(0x00);
+    popup_->SetOpacity(0.f);
     popup_->SetContentsView(view_);
 #if defined(USE_ASH)
     ash::wm::GetWindowState(popup_->GetNativeWindow())->
         set_ignored_by_shelf(true);
 #endif
     RepositionPopup();
   }
 }
 
 void StatusBubbleViews::Reposition() {
@@ skipping 272 matching lines @@
 void StatusBubbleViews::SetBubbleWidth(int width) {
   size_.set_width(width);
   SetBounds(original_position_.x(), original_position_.y(),
             size_.width(), size_.height());
 }
 
 void StatusBubbleViews::CancelExpandTimer() {
   if (expand_timer_factory_.HasWeakPtrs())
     expand_timer_factory_.InvalidateWeakPtrs();
 }