Switch to standard integer types in media/.

media/capture/content/animated_content_sampler.cc

 // Copyright (c) 2015 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 "media/capture/content/animated_content_sampler.h"
 
 #include <algorithm>
 
 namespace media {
 
@@ skipping 142 matching lines @@
       base::TimeDelta::FromMilliseconds(kMaxObservationWindowMillis);
   while ((event_time - observations_.front().event_time) > threshold)
     observations_.pop_front();
 }
 
 gfx::Rect AnimatedContentSampler::ElectMajorityDamageRect() const {
   // This is an derivative of the Boyer-Moore Majority Vote Algorithm where each
   // pixel in a candidate gets one vote, as opposed to each candidate getting
   // one vote.
   const gfx::Rect* candidate = NULL;
-  int64 votes = 0;
+  int64_t votes = 0;
   for (ObservationFifo::const_iterator i = observations_.begin();
        i != observations_.end(); ++i) {
     DCHECK_GT(i->damage_rect.size().GetArea(), 0);
     if (votes == 0) {
       candidate = &(i->damage_rect);
       votes = candidate->size().GetArea();
     } else if (i->damage_rect == *candidate) {
       votes += i->damage_rect.size().GetArea();
     } else {
       votes -= i->damage_rect.size().GetArea();
@@ skipping 10 matching lines @@
     base::TimeTicks event_time,
     gfx::Rect* rect,
     base::TimeDelta* period) const {
   const gfx::Rect elected_rect = ElectMajorityDamageRect();
   if (elected_rect.IsEmpty())
     return false;  // There is no regular animation present.
 
   // Scan |observations_|, gathering metrics about the ones having a damage Rect
   // equivalent to the |elected_rect|.  Along the way, break early whenever the
   // event times reveal a non-animating period.
-  int64 num_pixels_damaged_in_all = 0;
-  int64 num_pixels_damaged_in_chosen = 0;
+  int64_t num_pixels_damaged_in_all = 0;
+  int64_t num_pixels_damaged_in_chosen = 0;
   base::TimeDelta sum_frame_durations;
   size_t count_frame_durations = 0;
   base::TimeTicks first_event_time;
   base::TimeTicks last_event_time;
   for (ObservationFifo::const_reverse_iterator i = observations_.rbegin();
        i != observations_.rend(); ++i) {
     const int area = i->damage_rect.size().GetArea();
     num_pixels_damaged_in_all += area;
     if (i->damage_rect != elected_rect)
       continue;
@@ skipping 35 matching lines @@
   const base::TimeTicks ideal_timestamp = frame_timestamp_ + sampling_period_;
 
   // Account for two main sources of drift: 1) The clock drift of the system
   // clock relative to the video hardware, which affects the event times; and
   // 2) The small error introduced by this frame timestamp rewriting, as it is
   // based on averaging over recent events.
   //
   // TODO(miu): This is similar to the ClockSmoother in
   // media/base/audio_shifter.cc.  Consider refactor-and-reuse here.
   const base::TimeDelta drift = ideal_timestamp - event_time;
-  const int64 correct_over_num_frames =
+  const int64_t correct_over_num_frames =
       base::TimeDelta::FromMilliseconds(kDriftCorrectionMillis) /
       sampling_period_;
   DCHECK_GT(correct_over_num_frames, 0);
 
   return ideal_timestamp - drift / correct_over_num_frames;
 }
 
 // static
 base::TimeDelta AnimatedContentSampler::ComputeSamplingPeriod(
     base::TimeDelta animation_period,
     base::TimeDelta target_sampling_period,
     base::TimeDelta min_capture_period) {
   // If the animation rate is unknown, return the ideal sampling period.
   if (animation_period == base::TimeDelta()) {
     return std::max(target_sampling_period, min_capture_period);
   }
 
   // Determine whether subsampling is needed.  If so, compute the sampling
   // period corresponding to the sampling rate is the closest integer division
   // of the animation frame rate to the target sampling rate.
   //
   // For example, consider a target sampling rate of 30 FPS and an animation
   // rate of 42 FPS.  Possible sampling rates would be 42/1 = 42, 42/2 = 21,
   // 42/3 = 14, and so on.  Of these candidates, 21 FPS is closest to 30.
   base::TimeDelta sampling_period;
   if (animation_period < target_sampling_period) {
-    const int64 ratio = target_sampling_period / animation_period;
+    const int64_t ratio = target_sampling_period / animation_period;
     const double target_fps = 1.0 / target_sampling_period.InSecondsF();
     const double animation_fps = 1.0 / animation_period.InSecondsF();
     if (std::abs(animation_fps / ratio - target_fps) <
         std::abs(animation_fps / (ratio + 1) - target_fps)) {
       sampling_period = ratio * animation_period;
     } else {
       sampling_period = (ratio + 1) * animation_period;
     }
   } else {
     sampling_period = animation_period;
   }
   return std::max(sampling_period, min_capture_period);
 }
 
 }  // namespace media