DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove TimeRanges.

Browse Source 
R=abarth@chromium.org

Review URL: https://codereview.chromium.org/709133004
This commit is contained in:
Elliott Sprehn 2014-11-07 15:18:23 -08:00
parent 091a5611db
commit 2ee266238d
6 changed files with 0 additions and 725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
engine/core/core.gni
View File

@ -772,8 +772,6 @@ sky_core_files = [
"html/ImageData.cpp",
"html/ImageData.h",
"html/TextMetrics.h",
"html/TimeRanges.cpp",
"html/TimeRanges.h",
"html/URLRegistry.h",
"html/canvas/ANGLEInstancedArrays.cpp",
"html/canvas/ANGLEInstancedArrays.h",
@ -1235,7 +1233,6 @@ core_idl_files = get_path_info([
"html/HTMLTitleElement.idl",
"html/ImageData.idl",
"html/TextMetrics.idl",
"html/TimeRanges.idl",
"html/VoidCallback.idl",
"html/canvas/ANGLEInstancedArrays.idl",
"html/canvas/Canvas2DContextAttributes.idl",

206
engine/core/html/TimeRanges.cpp
View File

@ -1,206 +0,0 @@
/*
* 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
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "core/html/TimeRanges.h"
#include "bindings/core/v8/ExceptionMessages.h"
#include "bindings/core/v8/ExceptionState.h"
#include "bindings/core/v8/ExceptionStatePlaceholder.h"
#include "core/dom/ExceptionCode.h"
#include <math.h>
using namespace blink;
TimeRanges::TimeRanges(double start, double end)
{
ScriptWrappable::init(this);
add(start, end);
}
PassRefPtr<TimeRanges> TimeRanges::create(const blink::WebTimeRanges& webRanges)
{
RefPtr<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();
}
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();
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;
RefPtr<TimeRanges> invertedOther = other->copy();
invertedOther->invert();
invert();
unionWith(invertedOther.get());
invert();
}
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);
}
double TimeRanges::start(unsigned index, ExceptionState& exceptionState) const
{
if (index >= length()) {
exceptionState.throwDOMException(IndexSizeError, ExceptionMessages::indexExceedsMaximumBound("index", index, length()));
return 0;
}
return m_ranges[index].m_start;
}
double TimeRanges::end(unsigned index, ExceptionState& exceptionState) const
{
if (index >= length()) {
exceptionState.throwDOMException(IndexSizeError, ExceptionMessages::indexExceedsMaximumBound("index", index, length()));
return 0;
}
return m_ranges[index].m_end;
}
void TimeRanges::add(double start, double end)
{
ASSERT(start <= end);
unsigned 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.
//
// TODO: Given that we assume that ranges are correctly ordered, this could be optimized.
for (overlappingArcIndex = 0; overlappingArcIndex < m_ranges.size(); overlappingArcIndex++) {
if (addedRange.isOverlappingRange(m_ranges[overlappingArcIndex])
|| addedRange.isContiguousWithRange(m_ranges[overlappingArcIndex])) {
// We need to merge the addedRange and that range.
addedRange = addedRange.unionWithOverlappingOrContiguousRange(m_ranges[overlappingArcIndex]);
m_ranges.remove(overlappingArcIndex);
overlappingArcIndex--;
} else {
// Check the case for which there is no more to do
if (!overlappingArcIndex) {
if (addedRange.isBeforeRange(m_ranges[0])) {
// First index, and we are completely before that range (and not contiguous, nor overlapping).
// We just need to be inserted here.
break;
}
} else {
if (m_ranges[overlappingArcIndex - 1].isBeforeRange(addedRange)
&& addedRange.isBeforeRange(m_ranges[overlappingArcIndex])) {
// We are exactly after the current previous range, and before the current range, while
// not overlapping with none of them. Insert here.
break;
}
}
}
}
// Now that we are sure we don't overlap with any range, just add it.
m_ranges.insert(overlappingArcIndex, addedRange);
}
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;
}
double TimeRanges::nearest(double time) const
{
double closest = 0;
unsigned count = length();
for (unsigned ndx = 0; ndx < count; ndx++) {
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 = fabs(startTime - time);
else if (fabs(endTime - time) < closest)
closest = fabs(endTime - time);
}
return closest;
}
void TimeRanges::trace(Visitor* visitor)
{
visitor->trace(m_ranges);
}

133
engine/core/html/TimeRanges.h
View File

@ -1,133 +0,0 @@
/*
* Copyright (C) 2007, 2009 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
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TimeRanges_h
#define TimeRanges_h
#include "bindings/core/v8/ScriptWrappable.h"
#include "public/platform/WebTimeRange.h"
#include "wtf/PassRefPtr.h"
#include "wtf/RefCounted.h"
#include "wtf/Vector.h"
#include <algorithm>
namespace blink {
class ExceptionState;
class TimeRanges : public RefCounted<TimeRanges>, public ScriptWrappable {
DEFINE_WRAPPERTYPEINFO();
public:
// We consider all the Ranges to be semi-bounded as follow: [start, end[
struct Range {
ALLOW_ONLY_INLINE_ALLOCATION();
public:
Range() { }
Range(double start, double end)
{
m_start = start;
m_end = end;
}
double m_start;
double m_end;
inline bool isPointInRange(double point) const
{
return m_start <= point && point < m_end;
}
inline bool isOverlappingRange(const Range& range) const
{
return isPointInRange(range.m_start) || isPointInRange(range.m_end) || range.isPointInRange(m_start);
}
inline bool isContiguousWithRange(const Range& range) const
{
return range.m_start == m_end || range.m_end == m_start;
}
inline Range unionWithOverlappingOrContiguousRange(const Range& range) const
{
Range ret;
ret.m_start = std::min(m_start, range.m_start);
ret.m_end = std::max(m_end, range.m_end);
return ret;
}
inline bool isBeforeRange(const Range& range) const
{
return range.m_start >= m_end;
}
void trace(Visitor*) { }
};
static PassRefPtr<TimeRanges> create()
{
return adoptRef(new TimeRanges);
}
static PassRefPtr<TimeRanges> create(double start, double end)
{
return adoptRef(new TimeRanges(start, end));
}
static PassRefPtr<TimeRanges> create(const blink::WebTimeRanges&);
PassRefPtr<TimeRanges> copy() const;
void intersectWith(const TimeRanges*);
void unionWith(const TimeRanges*);
unsigned length() const { return m_ranges.size(); }
double start(unsigned index, ExceptionState&) const;
double end(unsigned index, ExceptionState&) const;
void add(double start, double end);
bool contain(double time) const;
double nearest(double time) const;
void trace(Visitor*);
private:
TimeRanges()
{
ScriptWrappable::init(this);
}
TimeRanges(double start, double end);
void invert();
Vector<Range> m_ranges;
};
} // namespace blink
WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::TimeRanges::Range);
#endif // TimeRanges_h

33
engine/core/html/TimeRanges.idl
View File

@ -1,33 +0,0 @@
/*
* Copyright (C) 2007, 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
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
[
RuntimeEnabled=Media
] interface TimeRanges {
readonly attribute unsigned long length;
[RaisesException] double start(unsigned long index);
[RaisesException] double end(unsigned long index);
};

300
engine/core/html/TimeRangesTest.cpp
View File

@ -1,300 +0,0 @@
/*
* Copyright (c) 2013, Google 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:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "core/html/TimeRanges.h"
#include "bindings/core/v8/ExceptionStatePlaceholder.h"
#include <gtest/gtest.h>
#include <sstream>
using blink::TimeRanges;
static std::string ToString(const TimeRanges& ranges)
{
std::stringstream ss;
ss << "{";
for (unsigned i = 0; i < ranges.length(); ++i)
ss << " [" << ranges.start(i, IGNORE_EXCEPTION) << "," << ranges.end(i, IGNORE_EXCEPTION) << ")";
ss << " }";
return ss.str();
}
#define ASSERT_RANGE(expected, range) ASSERT_EQ(expected, ToString(*range))
TEST(TimeRanges, Empty)
{
ASSERT_RANGE("{ }", TimeRanges::create());
}
TEST(TimeRanges, SingleRange)
{
ASSERT_RANGE("{ [1,2) }", TimeRanges::create(1, 2));
}
TEST(TimeRanges, CreateFromWebTimeRanges)
{
blink::WebTimeRanges webRanges(static_cast<size_t>(2));
webRanges[0].start = 0;
webRanges[0].end = 1;
webRanges[1].start = 2;
webRanges[1].end = 3;
ASSERT_RANGE("{ [0,1) [2,3) }", TimeRanges::create(webRanges));
}
TEST(TimeRanges, AddOrder)
{
RefPtr<TimeRanges> rangeA = TimeRanges::create();
RefPtr<TimeRanges> rangeB = TimeRanges::create();
rangeA->add(0, 2);
rangeA->add(3, 4);
rangeA->add(5, 100);
std::string expected = "{ [0,2) [3,4) [5,100) }";
ASSERT_RANGE(expected, rangeA);
// Add the values in rangeA to rangeB in reverse order.
for (int i = rangeA->length() - 1; i >= 0; --i)
rangeB->add(rangeA->start(i, IGNORE_EXCEPTION), rangeA->end(i, IGNORE_EXCEPTION));
ASSERT_RANGE(expected, rangeB);
}
TEST(TimeRanges, OverlappingAdds)
{
RefPtr<TimeRanges> ranges = TimeRanges::create();
ranges->add(0, 2);
ranges->add(10, 11);
ASSERT_RANGE("{ [0,2) [10,11) }", ranges);
ranges->add(0, 2);
ASSERT_RANGE("{ [0,2) [10,11) }", ranges);
ranges->add(2, 3);
ASSERT_RANGE("{ [0,3) [10,11) }", ranges);
ranges->add(2, 6);
ASSERT_RANGE("{ [0,6) [10,11) }", ranges);
ranges->add(9, 10);
ASSERT_RANGE("{ [0,6) [9,11) }", ranges);
ranges->add(8, 10);
ASSERT_RANGE("{ [0,6) [8,11) }", ranges);
ranges->add(-1, 7);
ASSERT_RANGE("{ [-1,7) [8,11) }", ranges);
ranges->add(6, 9);
ASSERT_RANGE("{ [-1,11) }", ranges);
}
TEST(TimeRanges, IntersectWith_Self)
{
RefPtr<TimeRanges> ranges = TimeRanges::create(0, 2);
ASSERT_RANGE("{ [0,2) }", ranges);
ranges->intersectWith(ranges.get());
ASSERT_RANGE("{ [0,2) }", ranges);
}
TEST(TimeRanges, IntersectWith_IdenticalRange)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create(0, 2);
RefPtr<TimeRanges> rangesB = rangesA->copy();
ASSERT_RANGE("{ [0,2) }", rangesA);
ASSERT_RANGE("{ [0,2) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [0,2) }", rangesA);
ASSERT_RANGE("{ [0,2) }", rangesB);
}
TEST(TimeRanges, IntersectWith_Empty)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create(0, 2);
RefPtr<TimeRanges> rangesB = TimeRanges::create();
ASSERT_RANGE("{ [0,2) }", rangesA);
ASSERT_RANGE("{ }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ }", rangesA);
ASSERT_RANGE("{ }", rangesB);
}
TEST(TimeRanges, IntersectWith_DisjointRanges1)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 1);
rangesA->add(4, 5);
rangesB->add(2, 3);
rangesB->add(6, 7);
ASSERT_RANGE("{ [0,1) [4,5) }", rangesA);
ASSERT_RANGE("{ [2,3) [6,7) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ }", rangesA);
ASSERT_RANGE("{ [2,3) [6,7) }", rangesB);
}
TEST(TimeRanges, IntersectWith_DisjointRanges2)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 1);
rangesA->add(4, 5);
rangesB->add(1, 4);
rangesB->add(5, 7);
ASSERT_RANGE("{ [0,1) [4,5) }", rangesA);
ASSERT_RANGE("{ [1,4) [5,7) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ }", rangesA);
ASSERT_RANGE("{ [1,4) [5,7) }", rangesB);
}
TEST(TimeRanges, IntersectWith_CompleteOverlap1)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(1, 3);
rangesA->add(4, 5);
rangesA->add(6, 9);
rangesB->add(0, 10);
ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA);
ASSERT_RANGE("{ [0,10) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA);
ASSERT_RANGE("{ [0,10) }", rangesB);
}
TEST(TimeRanges, IntersectWith_CompleteOverlap2)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(1, 3);
rangesA->add(4, 5);
rangesA->add(6, 9);
rangesB->add(1, 9);
ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA);
ASSERT_RANGE("{ [1,9) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA);
ASSERT_RANGE("{ [1,9) }", rangesB);
}
TEST(TimeRanges, IntersectWith_Gaps1)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 2);
rangesA->add(4, 6);
rangesB->add(1, 5);
ASSERT_RANGE("{ [0,2) [4,6) }", rangesA);
ASSERT_RANGE("{ [1,5) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [1,2) [4,5) }", rangesA);
ASSERT_RANGE("{ [1,5) }", rangesB);
}
TEST(TimeRanges, IntersectWith_Gaps2)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 2);
rangesA->add(4, 6);
rangesA->add(8, 10);
rangesB->add(1, 9);
ASSERT_RANGE("{ [0,2) [4,6) [8,10) }", rangesA);
ASSERT_RANGE("{ [1,9) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [1,2) [4,6) [8,9) }", rangesA);
ASSERT_RANGE("{ [1,9) }", rangesB);
}
TEST(TimeRanges, IntersectWith_Gaps3)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 2);
rangesA->add(4, 7);
rangesA->add(8, 10);
rangesB->add(1, 5);
rangesB->add(6, 9);
ASSERT_RANGE("{ [0,2) [4,7) [8,10) }", rangesA);
ASSERT_RANGE("{ [1,5) [6,9) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [1,2) [4,5) [6,7) [8,9) }", rangesA);
ASSERT_RANGE("{ [1,5) [6,9) }", rangesB);
}

50
engine/public/platform/WebTimeRange.h
View File

@ -1,50 +0,0 @@
/*
* Copyright (C) 2012 Google 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:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef WebTimeRange_h
#define WebTimeRange_h
#include "WebVector.h"
namespace blink {
struct WebTimeRange {
WebTimeRange() : start(0), end(0) { }
WebTimeRange(double s, double e) : start(s), end(e) { }
double start;
double end;
};
typedef WebVector<WebTimeRange> WebTimeRanges;
} // namespace blink
#endif