Keep auxilliary media objects on the heap always.

Source/core/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 21 matching lines @@
 #include "core/dom/ExceptionCode.h"
 #include <math.h>
 
 using namespace blink;
 
 TimeRanges::TimeRanges(double start, double end)
 {
     add(start, end);
 }
 
-PassRefPtrWillBeRawPtr<TimeRanges> TimeRanges::create(const blink::WebTimeRanges& webRanges)
+TimeRanges* TimeRanges::create(const blink::WebTimeRanges& webRanges)
 {
-    RefPtrWillBeRawPtr<TimeRanges> ranges = TimeRanges::create();
+    TimeRanges* ranges = TimeRanges::create();
 
     unsigned size = webRanges.size();
     for (unsigned i = 0; i < size; ++i)
         ranges->add(webRanges[i].start, webRanges[i].end);
 
-    return ranges.release();
+    return ranges;
 }
 
-PassRefPtrWillBeRawPtr<TimeRanges> TimeRanges::copy() const
+TimeRanges* TimeRanges::copy() const
 {
-    RefPtrWillBeRawPtr<TimeRanges> newSession = TimeRanges::create();
+    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();
+    return newSession;
 }
 
 void TimeRanges::invert()
 {
-    RefPtrWillBeRawPtr<TimeRanges> inverted = TimeRanges::create();
+    TimeRanges* inverted = TimeRanges::create();
     double posInf = std::numeric_limits<double>::infinity();
     double negInf = -std::numeric_limits<double>::infinity();
 
     if (!m_ranges.size()) {
         inverted->add(negInf, posInf);
     } else {
         double start = m_ranges.first().m_start;
         if (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);
 
         double end = m_ranges.last().m_end;
         if (end != posInf)
             inverted->add(end, posInf);
     }
 
     m_ranges.swap(inverted->m_ranges);
 }
 
 void TimeRanges::intersectWith(const TimeRanges* other)
 {
     ASSERT(other);
 
     if (other == this)
         return;
 
-    RefPtrWillBeRawPtr<TimeRanges> invertedOther = other->copy();
+    TimeRanges* invertedOther = other->copy();
     invertedOther->invert();
 
     invert();
-    unionWith(invertedOther.get());
+    unionWith(invertedOther);
     invert();
 }
 
 void TimeRanges::unionWith(const TimeRanges* other)
 {
     ASSERT(other);
-    RefPtrWillBeRawPtr<TimeRanges> unioned = copy();
+    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);
 }
 
 double TimeRanges::start(unsigned index, ExceptionState& exceptionState) const
 {
@@ skipping 86 matching lines @@
         }
 
         if (delta < bestDelta || (delta == bestDelta
             && std::abs(currentPlaybackPosition - match) < std::abs(currentPlaybackPosition - bestMatch))) {
             bestDelta = delta;
             bestMatch = match;
         }
     }
     return bestMatch;
 }