Update all float attributes in HTMLMediaElement and related objects to double

Source/WebCore/html/TimeRanges.cpp

 /*
  * Copyright (C) 2007, 2009, 2010 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 16 matching lines @@
 
 #include "TimeRanges.h"
 
 #include "ExceptionCode.h"
 #include "ExceptionCodePlaceholder.h"
 #include <math.h>
 
 using namespace WebCore;
 using namespace std;
 
-TimeRanges::TimeRanges(float start, float end)
+TimeRanges::TimeRanges(double start, double end)
 {
     add(start, end);
 }
 
 PassRefPtr<TimeRanges> TimeRanges::copy() const
 {
     RefPtr<TimeRanges> newSession = TimeRanges::create();
-    
+
     unsigned size = m_ranges.size();
     for (unsigned i = 0; i < size; i++)
         newSession->add(m_ranges[i].m_start, m_ranges[i].m_end);
-    
+
     return newSession.release();
 }
 
 void TimeRanges::invert()
 {
     RefPtr<TimeRanges> inverted = TimeRanges::create();
-    float posInf = std::numeric_limits<float>::infinity();
-    float negInf = -std::numeric_limits<float>::infinity();
+    double posInf = std::numeric_limits<double>::infinity();
+    double negInf = -std::numeric_limits<double>::infinity();
 
     if (!m_ranges.size())
         inverted->add(negInf, posInf);
     else {
-        if (float start = m_ranges.first().m_start != negInf)
+        if (double start = m_ranges.first().m_start != negInf)
             inverted->add(negInf, start);
 
         for (size_t index = 0; index + 1 < m_ranges.size(); ++index)
             inverted->add(m_ranges[index].m_end, m_ranges[index + 1].m_start);
 
-        if (float end = m_ranges.last().m_end != posInf)
+        if (double end = m_ranges.last().m_end != posInf)
             inverted->add(end, posInf);
     }
 
     m_ranges.swap(inverted->m_ranges);
 }
 
 void TimeRanges::intersectWith(const TimeRanges* other)
 {
     ASSERT(other);
     RefPtr<TimeRanges> inverted = copy();
     RefPtr<TimeRanges> invertedOther = other->copy();
     inverted->unionWith(invertedOther.get());
     inverted->invert();
 
     m_ranges.swap(inverted->m_ranges);
 }
 
 void TimeRanges::unionWith(const TimeRanges* other)
 {
     ASSERT(other);
     RefPtr<TimeRanges> unioned = copy();
     for (size_t index = 0; index < other->m_ranges.size(); ++index) {
         const Range& range = other->m_ranges[index];
         unioned->add(range.m_start, range.m_end);
     }
 
     m_ranges.swap(unioned->m_ranges);
 }
 
-float TimeRanges::start(unsigned index, ExceptionCode& ec) const 
-{ 
+double TimeRanges::start(unsigned index, ExceptionCode& ec) const
+{
     if (index >= length()) {
         ec = INDEX_SIZE_ERR;
         return 0;
     }
     return m_ranges[index].m_start;
 }
 
-float TimeRanges::end(unsigned index, ExceptionCode& ec) const 
-{ 
+double TimeRanges::end(unsigned index, ExceptionCode& ec) const
+{
     if (index >= length()) {
         ec = INDEX_SIZE_ERR;
         return 0;
     }
     return m_ranges[index].m_end;
 }
 
-void TimeRanges::add(float start, float end) 
+void TimeRanges::add(double start, double end)
 {
     ASSERT(start <= end);
     unsigned int overlappingArcIndex;
     Range addedRange(start, end);
 
     // For each present range check if we need to:
     // - merge with the added range, in case we are overlapping or contiguous
     // - Need to insert in place, we we are completely, not overlapping and not contiguous
     // in between two ranges.
     //
@@ skipping 22 matching lines @@
                     break;
                 }
             }
         }
     }
 
     // Now that we are sure we don't overlap with any range, just add it.
     m_ranges.insert(overlappingArcIndex, addedRange);
 }
 
-bool TimeRanges::contain(float time) const
+bool TimeRanges::contain(double time) const
 {
     for (unsigned n = 0; n < length(); n++) {
         if (time >= start(n, IGNORE_EXCEPTION) && time <= end(n, IGNORE_EXCEPTION))
             return true;
     }
     return false;
 }
 
-float TimeRanges::nearest(float time) const
+double TimeRanges::nearest(double time) const
 {
-    float closest = 0;
+    double closest = 0;
     unsigned count = length();
     for (unsigned ndx = 0; ndx < count; ndx++) {
-        float startTime = start(ndx, IGNORE_EXCEPTION);
-        float endTime = end(ndx, IGNORE_EXCEPTION);
+        double startTime = start(ndx, IGNORE_EXCEPTION);
+        double endTime = end(ndx, IGNORE_EXCEPTION);
         if (time >= startTime && time <= endTime)
             return time;
         if (fabs(startTime - time) < closest)
             closest = fabsf(startTime - time);
         else if (fabs(endTime - time) < closest)
             closest = fabsf(endTime - time);
     }
     return closest;
 }