Import Cobalt 9.140119
Change-Id: Idfa97844364064c39ec81cbe3f998a22b7009be6
diff --git a/src/cobalt/base/c_val.cc b/src/cobalt/base/c_val.cc
index f0c9a84..d44f9fa 100644
--- a/src/cobalt/base/c_val.cc
+++ b/src/cobalt/base/c_val.cc
@@ -48,7 +48,9 @@
delete registered_vars_;
}
-void CValManager::RegisterCVal(const CValDetail::CValBase* cval) {
+void CValManager::RegisterCVal(
+ const CValDetail::CValBase* cval,
+ scoped_refptr<base::RefCountedThreadSafeLock>* value_lock) {
base::AutoLock auto_lock(cvals_lock_);
// CVals cannot share name. If this assert is triggered, we are trying to
@@ -57,6 +59,7 @@
DCHECK(registered_vars_->find(cval->GetName()) == registered_vars_->end());
(*registered_vars_)[cval->GetName()] = cval;
+ *value_lock = value_lock_refptr_;
}
void CValManager::UnregisterCVal(const CValDetail::CValBase* cval) {
diff --git a/src/cobalt/base/c_val.h b/src/cobalt/base/c_val.h
index 92f8f6c..e85b935 100644
--- a/src/cobalt/base/c_val.h
+++ b/src/cobalt/base/c_val.h
@@ -500,8 +500,10 @@
~CValManager();
// Called in CVal constructors to register/deregister themselves with the
- // system.
- void RegisterCVal(const CValDetail::CValBase* cval);
+ // system. Registering a CVal will also provide that CVal with a value lock
+ // to lock when it modifies its value.
+ void RegisterCVal(const CValDetail::CValBase* cval,
+ scoped_refptr<base::RefCountedThreadSafeLock>* value_lock);
void UnregisterCVal(const CValDetail::CValBase* cval);
#if defined(ENABLE_DEBUG_C_VAL)
@@ -586,7 +588,6 @@
CommonConstructor();
}
virtual ~CValImpl() {
- base::AutoLock auto_lock(value_lock_refptr_->GetLock());
if (registered_) {
CValManager::GetInstance()->UnregisterCVal(this);
}
@@ -673,8 +674,7 @@
void RegisterWithManager() {
if (!registered_) {
CValManager* manager = CValManager::GetInstance();
- manager->RegisterCVal(this);
- value_lock_refptr_ = manager->value_lock_refptr_;
+ manager->RegisterCVal(this, &value_lock_refptr_);
registered_ = true;
}
}
diff --git a/src/cobalt/base/c_val_collection_timer_stats.h b/src/cobalt/base/c_val_collection_timer_stats.h
index eda96b9..4f21cb7 100644
--- a/src/cobalt/base/c_val_collection_timer_stats.h
+++ b/src/cobalt/base/c_val_collection_timer_stats.h
@@ -63,6 +63,9 @@
start_time_ = base::TimeTicks();
}
+ // Stops any started timer and this sample is ignored.
+ void Cancel() { start_time_ = base::TimeTicks(); }
+
// Flush the collection. This causes |CValCollectionStats| to update its stats
// and clear the entries.
void Flush() { entry_stats_.Flush(); }
diff --git a/src/cobalt/base/c_val_test.cc b/src/cobalt/base/c_val_test.cc
index 3dc416d..6281766 100644
--- a/src/cobalt/base/c_val_test.cc
+++ b/src/cobalt/base/c_val_test.cc
@@ -13,7 +13,10 @@
// limitations under the License.
#include <limits>
+#include <utility>
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/simple_thread.h"
#include "base/time.h"
#include "cobalt/base/c_val.h"
#include "testing/gmock/include/gmock/gmock.h"
@@ -584,4 +587,113 @@
EXPECT_EQ(test_hook.value_changed_count_, 1);
}
+namespace {
+// Helper class for the RemoveAndRead test defined below.
+class ReadCValThread : public base::SimpleThread {
+ public:
+ ReadCValThread(const char* test_cval_name, int num_read_cycles,
+ std::pair<std::string, std::string> valid_values,
+ base::WaitableEvent* thread_ready_event,
+ base::WaitableEvent* start_processing_event)
+ : base::SimpleThread("ReadCValThread"),
+ test_cval_name_(test_cval_name),
+ num_read_cycles_(num_read_cycles),
+ valid_values_(valid_values),
+ thread_ready_event_(thread_ready_event),
+ start_processing_event_(start_processing_event) {}
+
+ void Run() OVERRIDE {
+ thread_ready_event_->Signal();
+ start_processing_event_->Wait();
+
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ for (int i = 0; i < num_read_cycles_; ++i) {
+ base::optional<std::string> result =
+ cvm->GetValueAsString(test_cval_name_);
+ if (result) {
+ EXPECT_TRUE(*result == valid_values_.first ||
+ *result == valid_values_.second);
+ }
+ }
+ }
+
+ private:
+ const char* test_cval_name_;
+ int num_read_cycles_;
+ std::pair<std::string, std::string> valid_values_;
+ base::WaitableEvent* thread_ready_event_;
+ base::WaitableEvent* start_processing_event_;
+};
+
+// Helper class for the RemoveAndRead test defined below.
+class CreateDestroyCValThread : public base::SimpleThread {
+ public:
+ CreateDestroyCValThread(const char* test_cval_name,
+ int num_create_destroy_cycles,
+ std::pair<std::string, std::string> valid_values,
+ base::WaitableEvent* thread_ready_event,
+ base::WaitableEvent* start_processing_event)
+ : base::SimpleThread("CreateDestroyCValThread"),
+ test_cval_name_(test_cval_name),
+ num_create_destroy_cycles_(num_create_destroy_cycles),
+ valid_values_(valid_values),
+ thread_ready_event_(thread_ready_event),
+ start_processing_event_(start_processing_event) {}
+
+ void Run() OVERRIDE {
+ thread_ready_event_->Signal();
+ start_processing_event_->Wait();
+
+ for (int i = 0; i < num_create_destroy_cycles_; ++i) {
+ base::CVal<std::string> test_cval(test_cval_name_, valid_values_.first,
+ "Description");
+ test_cval = valid_values_.second;
+ }
+ }
+
+ private:
+ const char* test_cval_name_;
+ int num_create_destroy_cycles_;
+ std::pair<std::string, std::string> valid_values_;
+ base::WaitableEvent* thread_ready_event_;
+ base::WaitableEvent* start_processing_event_;
+};
+
+} // namespace
+
+// Tests that we can create and destroy cvals no problem while simultaneously
+// reading from them. The test creates two threads, a reader thread and a
+// creater/destroyer (and writer) thread. These both attempt to access the same
+// cval as fast as possible.
+TEST(CValTest, RemoveAndRead) {
+ const char* kTestCValName = "TestCVal";
+ const int kNumReadCycles = 10000;
+ const int kNuMCreateDestroyCycles = 10000;
+ const std::pair<std::string, std::string> valid_values("hello", "66");
+ base::WaitableEvent read_cval_thread_ready(true, false);
+ base::WaitableEvent create_destroy_cval_thread_ready(true, false);
+ base::WaitableEvent start_processing_event(true, false);
+
+ // Create and start both threads.
+ ReadCValThread read_cval_thread(kTestCValName, kNumReadCycles, valid_values,
+ &read_cval_thread_ready,
+ &start_processing_event);
+ CreateDestroyCValThread create_destroy_cval_thread(
+ kTestCValName, kNuMCreateDestroyCycles, valid_values,
+ &create_destroy_cval_thread_ready, &start_processing_event);
+ read_cval_thread.Start();
+ create_destroy_cval_thread.Start();
+
+ // Wait until both threads are initialized and ready.
+ read_cval_thread_ready.Wait();
+ create_destroy_cval_thread_ready.Wait();
+
+ // Signal for the processing/testing to begin.
+ start_processing_event.Signal();
+
+ // Wait for both threads to complete.
+ read_cval_thread.Join();
+ create_destroy_cval_thread.Join();
+}
+
} // namespace base
diff --git a/src/cobalt/base/clock.h b/src/cobalt/base/clock.h
index 01d5442..e2a4bbc 100644
--- a/src/cobalt/base/clock.h
+++ b/src/cobalt/base/clock.h
@@ -49,6 +49,31 @@
~SystemMonotonicClock() OVERRIDE {}
};
+// The MinimumResolutionClock modifies the output of an existing clock by
+// clamping its minimum resolution to a predefined amount. This is implemented
+// by rounding down the existing clock's time to the previous multiple of the
+// desired clock resolution.
+class MinimumResolutionClock : public Clock {
+ public:
+ MinimumResolutionClock(scoped_refptr<Clock> parent,
+ const base::TimeDelta& min_resolution)
+ : parent_(parent),
+ min_resolution_in_microseconds_(min_resolution.InMicroseconds()) {
+ DCHECK(parent);
+ }
+
+ base::TimeDelta Now() OVERRIDE {
+ base::TimeDelta now = parent_->Now();
+ int64 microseconds = now.InMicroseconds();
+ return base::TimeDelta::FromMicroseconds(
+ microseconds - (microseconds % min_resolution_in_microseconds_));
+ }
+
+ private:
+ scoped_refptr<Clock> parent_;
+ const int64_t min_resolution_in_microseconds_;
+};
+
// The OffsetClock takes a parent clock and an offset upon construction, and
// when queried for the time it returns the time of the parent clock offset by
// the specified offset.
diff --git a/src/cobalt/browser/application.cc b/src/cobalt/browser/application.cc
index 236fcef..29b055b 100644
--- a/src/cobalt/browser/application.cc
+++ b/src/cobalt/browser/application.cc
@@ -317,6 +317,8 @@
"h5vcc-location-src "
"https://www.youtube.com/tv "
"https://www.youtube.com/tv/ "
+ "https://web-green-qa.youtube.com/tv "
+ "https://web-green-qa.youtube.com/tv/ "
"https://web-release-qa.youtube.com/tv "
"https://web-release-qa.youtube.com/tv/ "
#if defined(ENABLE_ABOUT_SCHEME)
diff --git a/src/cobalt/browser/web_module.cc b/src/cobalt/browser/web_module.cc
index b916179..b575c58 100644
--- a/src/cobalt/browser/web_module.cc
+++ b/src/cobalt/browser/web_module.cc
@@ -624,7 +624,7 @@
web_module_stat_tracker_->OnEndInjectEvent(
window_->HasPendingAnimationFrameCallbacks(),
- layout_manager_->IsNewRenderTreePending());
+ layout_manager_->IsRenderTreePending());
}
void WebModule::Impl::ExecuteJavascript(
@@ -657,7 +657,7 @@
// Notify the stat tracker that the animation frame callbacks have finished.
// This may end the current event being tracked.
web_module_stat_tracker_->OnRanAnimationFrameCallbacks(
- layout_manager_->IsNewRenderTreePending());
+ layout_manager_->IsRenderTreePending());
}
void WebModule::Impl::OnRenderTreeProduced(
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index 05f7d20..2f807b4 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-96542
\ No newline at end of file
+140119
\ No newline at end of file
diff --git a/src/cobalt/build/config/base.gypi b/src/cobalt/build/config/base.gypi
index ee9c278..da47e25 100644
--- a/src/cobalt/build/config/base.gypi
+++ b/src/cobalt/build/config/base.gypi
@@ -47,38 +47,22 @@
# Contains the current font package selection. This can be used to trade
# font quality, coverage, and latency for different font package sizes.
# The font package can be one of the following options:
- # 'expanded' -- The largest package. It includes everything in the
- # 'standard' package, along with 'bold' weight CJK. It is
- # recommended that 'local_font_cache_size_in_bytes' be
- # increased to 24MB when using this package to account for
- # the extra memory required by bold CJK. This package is
- # ~48.7MB.
# 'standard' -- The default package. It includes all sans-serif, serif,
# and FCC fonts, non-CJK fallback fonts in both 'normal' and
- # 'bold' weights, and 'normal' weight CJK ('bold' weight CJK
- # is synthesized from it). This package is ~29.4MB.
- # 'limited_with_jp' -- A significantly smaller package than 'standard'.
- # This package removes all but 'normal' and 'bold' weighted
+ # 'bold' weights, and 'normal' weight CJK ('bold' weight
+ # CJK is synthesized from it). This package is ~29.4MB.
+ # 'limited' -- A significantly smaller package than 'standard'. This
+ # package removes all but 'normal' and 'bold' weighted
# sans-serif and serif, removes the FCC fonts (which must be
# provided by the system or downloaded from the web),
- # removes the 'bold' weighted non-CJK fallback fonts (the
- # 'normal' weight is still included and is used to
- # synthesize bold), and replaces standard CJK with low
- # quality CJK. However, higher quality Japanese is still
- # included. Because low quality CJK cannot synthesize bold,
- # bold glyphs are unavailable in Chinese and Korean. This
- # package is ~10.9MB.
- # 'limited' -- A smaller package than 'limited_with_jp'. The two packages
- # are identical with the exception that 'limited' does not
- # include the higher quality Japanese font; instead it
- # relies on low quality CJK for all CJK characters. Because
+ # and replaces standard CJK with low quality CJK. Because
# low quality CJK cannot synthesize bold, bold glyphs are
- # unavailable in Chinese, Japanese, and Korean. This package
+ # unavailable in Chinese, Japanese and Korean. This package
# is ~7.7MB.
# 'minimal' -- The smallest possible font package. It only includes
# Roboto's Basic Latin characters. Everything else must be
# provided by the system or downloaded from the web. This
- # package is ~16.4KB.
+ # package is ~35.4KB.
# NOTE: When bold is needed, but unavailable, it is typically synthesized,
# resulting in lower quality glyphs than those generated directly from
# a bold font. However, this does not occur with low quality CJK,
@@ -111,7 +95,6 @@
'cobalt_font_package_override_fallback_lang_non_cjk%': -1,
'cobalt_font_package_override_fallback_lang_cjk%': -1,
'cobalt_font_package_override_fallback_lang_cjk_low_quality%': -1,
- 'cobalt_font_package_override_fallback_lang_jp%': -1,
'cobalt_font_package_override_fallback_emoji%': -1,
'cobalt_font_package_override_fallback_symbols%': -1,
diff --git a/src/cobalt/content/fonts/README.md b/src/cobalt/content/fonts/README.md
index 1181646..0c2edfc 100644
--- a/src/cobalt/content/fonts/README.md
+++ b/src/cobalt/content/fonts/README.md
@@ -41,23 +41,6 @@
}
### Package Profiles
-* 'expanded' -- The largest package. It includes everything in the 'standard'
- package, along with 'bold' weight CJK. It is recommended that
- 'local_font_cache_size_in_bytes' be increased to 24MB when
- using this package to account for the extra memory required by
- bold CJK. This package is ~48.7MB.
-
- Package category values:
- 'package_named_sans_serif': 4,
- 'package_named_serif': 3,
- 'package_named_fcc_fonts': 2,
- 'package_fallback_lang_non_cjk': 2,
- 'package_fallback_lang_cjk': 2,
- 'package_fallback_lang_cjk_low_quality': 0,
- 'package_fallback_lang_jp': 0,
- 'package_fallback_emoji': 1,
- 'package_fallback_symbols': 1,
-
* 'standard' -- The default package. It includes all sans-serif, serif, and FCC
fonts, non-CJK fallback fonts in both 'normal' and 'bold'
weights, and 'normal' weight CJK ('bold' weight CJK is
@@ -70,20 +53,16 @@
'package_fallback_lang_non_cjk': 2,
'package_fallback_lang_cjk': 1,
'package_fallback_lang_cjk_low_quality': 0,
- 'package_fallback_lang_jp': 0,
'package_fallback_emoji': 1,
'package_fallback_symbols': 1,
-* 'limited_with_jp' -- A significantly smaller package than 'standard'. This
- package removes all but 'normal' and 'bold' weighted sans-serif
- and serif, removes the FCC fonts (which must be provided by the
- system or downloaded from the web), removes the 'bold' weighted
- non-CJK fallback fonts (the 'normal' weight is still included
- and is used to synthesize bold), and replaces standard CJK with
- low quality CJK. However, higher quality Japanese is still
- included. Because low quality CJK cannot synthesize bold, bold
- glyphs are unavailable in Chinese and Korean. This package is
- ~10.9MB.
+* 'limited' -- A significantly smaller package than 'standard'. This package
+ removes all but 'normal' and 'bold' weighted sans-serif and
+ serif, removes the FCC fonts (which must be provided by the
+ system or downloaded from the web), and replaces standard CJK
+ with low quality CJK. Because low quality CJK cannot synthesize
+ bold, bold glyphs are unavailable in Chinese, Japanese and
+ Korean. This package is ~7.7MB.
Package category values:
'package_named_sans_serif': 2,
@@ -92,31 +71,12 @@
'package_fallback_lang_non_cjk': 1,
'package_fallback_lang_cjk': 0,
'package_fallback_lang_cjk_low_quality': 1,
- 'package_fallback_lang_jp': 1,
- 'package_fallback_emoji': 1,
- 'package_fallback_symbols': 1,
-
-* 'limited' -- A smaller package than 'limited_with_jp'. The two packages are
- identical with the exception that 'limited' does not include
- the higher quality Japanese font; instead it relies on low
- quality CJK for all CJK characters. Because low quality CJK
- cannot synthesize bold, bold glyphs are unavailable in Chinese,
- Japanese, and Korean. This package is ~7.7MB.
-
- Package category values:
- 'package_named_sans_serif': 2,
- 'package_named_serif': 0,
- 'package_named_fcc_fonts': 0,
- 'package_fallback_lang_non_cjk': 1,
- 'package_fallback_lang_cjk': 0,
- 'package_fallback_lang_cjk_low_quality': 1,
- 'package_fallback_lang_jp': 0,
'package_fallback_emoji': 1,
'package_fallback_symbols': 1,
* 'minimal' -- The smallest possible font package. It only includes Roboto's
Basic Latin characters. Everything else must be provided by the
- system or downloaded from the web. This package is ~16.4KB.
+ system or downloaded from the web. This package is ~35.4KB.
Package category values:
'package_named_sans_serif': 0,
@@ -125,7 +85,6 @@
'package_fallback_lang_non_cjk': 0,
'package_fallback_lang_cjk': 0,
'package_fallback_lang_cjk_low_quality': 0,
- 'package_fallback_lang_jp': 0,
'package_fallback_emoji': 0,
'package_fallback_symbols': 0,
@@ -160,10 +119,6 @@
included when 'package_fallback_lang_cjk' has a value of '0'. This is the
only category of fonts that is not synthetically boldable.
- * 'package_fallback_lang_jp':
- Higher quality Japanese language-specific fallback fonts. These should
- only be included when 'package_fallback_lang_cjk' has a value of '0'.
-
* 'package_fallback_emoji':
Emoji-related fallback fonts.
@@ -219,8 +174,6 @@
'package_fallback_lang_cjk'
* 'cobalt_font_package_override_fallback_lang_cjk_low_quality' ==>
'package_fallback_lang_cjk_low_quality'
- * 'cobalt_font_package_override_fallback_lang_jp' ==>
- 'package_fallback_lang_jp'
* 'cobalt_font_package_override_fallback_emoji' ==>
'package_fallback_emoji'
* 'cobalt_font_package_override_fallback_symbols' ==>
diff --git a/src/cobalt/content/fonts/config/common/fonts.xml b/src/cobalt/content/fonts/config/common/fonts.xml
index b60cc92..fc579cc 100644
--- a/src/cobalt/content/fonts/config/common/fonts.xml
+++ b/src/cobalt/content/fonts/config/common/fonts.xml
@@ -346,9 +346,6 @@
<family lang="ko" pages="0-4,17,30,32-39,41,43,46-159,169,172-215,249-251,254-255,497-498,512-658,660-682,685,687,689,691-696,698-702,704-718,760-761">
<font weight="400" style="normal" index="1">NotoSansCJK-Regular.ttc</font>
</family>
- <family lang="ja" pages="0,32,34-35,46-159,249-250,254-255,498,512-523,525-527,530-538,540-543,545-547,550,552,554-559,561,563-568,570,572-573,575-579,582-584,586-594,596-608,610-612,614-618,620,622-625,627-628,630-631,633-638,640,642-646,649-655,658,660-664,666,669-678,681,695-696,760-761">
- <font weight="400" style="normal">NotoSansJP-Regular.otf</font>
- </family>
<family pages="0,32-33,35-39,41,43,48,50,254,496-502,4068,4072">
<font weight="400" style="normal">NotoEmoji-Regular.ttf</font>
</family>
diff --git a/src/cobalt/content/fonts/font_files/NotoSansCJK-Bold.ttc b/src/cobalt/content/fonts/font_files/NotoSansCJK-Bold.ttc
deleted file mode 100644
index 09707f9..0000000
--- a/src/cobalt/content/fonts/font_files/NotoSansCJK-Bold.ttc
+++ /dev/null
Binary files differ
diff --git a/src/cobalt/content/fonts/font_files/NotoSansJP-Regular.otf b/src/cobalt/content/fonts/font_files/NotoSansJP-Regular.otf
deleted file mode 100644
index 40b064a..0000000
--- a/src/cobalt/content/fonts/font_files/NotoSansJP-Regular.otf
+++ /dev/null
Binary files differ
diff --git a/src/cobalt/dom/window.cc b/src/cobalt/dom/window.cc
index 3ca1222..89dd4ff 100644
--- a/src/cobalt/dom/window.cc
+++ b/src/cobalt/dom/window.cc
@@ -66,6 +66,14 @@
DISALLOW_COPY_AND_ASSIGN(RelayLoadEvent);
};
+namespace {
+// Ensure that the timer resolution is at the lowest 20 microseconds in
+// order to mitigate potential Spectre-related attacks. This is following
+// Mozilla's lead as described here:
+// https://www.mozilla.org/en-US/security/advisories/mfsa2018-01/
+const int64_t kPerformanceTimerMinResolutionInMicroseconds = 20;
+} // namespace
+
Window::Window(int width, int height, cssom::CSSParser* css_parser,
Parser* dom_parser, loader::FetcherFactory* fetcher_factory,
render_tree::ResourceProvider** resource_provider,
@@ -106,7 +114,10 @@
media_source_registry, resource_provider, animated_image_tracker,
image_cache, reduced_image_cache_capacity_manager,
remote_typeface_cache, mesh_cache, dom_stat_tracker, language)),
- performance_(new Performance(new base::SystemMonotonicClock())),
+ performance_(new Performance(new base::MinimumResolutionClock(
+ new base::SystemMonotonicClock(),
+ base::TimeDelta::FromMicroseconds(
+ kPerformanceTimerMinResolutionInMicroseconds)))),
ALLOW_THIS_IN_INITIALIZER_LIST(document_(new Document(
html_element_context_.get(),
Document::Options(
diff --git a/src/cobalt/layout/layout.cc b/src/cobalt/layout/layout.cc
index 2331e2e..1a26b41 100644
--- a/src/cobalt/layout/layout.cc
+++ b/src/cobalt/layout/layout.cc
@@ -127,20 +127,11 @@
}
}
-scoped_refptr<render_tree::Node> Layout(
- const icu::Locale& locale, const scoped_refptr<dom::Document>& document,
- int dom_max_element_depth, UsedStyleProvider* used_style_provider,
+scoped_refptr<render_tree::Node> GenerateRenderTreeFromBoxTree(
+ UsedStyleProvider* used_style_provider,
LayoutStatTracker* layout_stat_tracker,
- icu::BreakIterator* line_break_iterator,
- icu::BreakIterator* character_break_iterator,
scoped_refptr<BlockLevelBlockContainerBox>* initial_containing_block) {
- TRACE_EVENT0("cobalt::layout", "Layout()");
- UpdateComputedStylesAndLayoutBoxTree(
- locale, document, dom_max_element_depth, used_style_provider,
- layout_stat_tracker, line_break_iterator, character_break_iterator,
- initial_containing_block);
-
- // Add to render tree.
+ TRACE_EVENT0("cobalt::layout", "GenerateRenderTreeFromBoxTree()");
render_tree::CompositionNode::Builder render_tree_root_builder;
{
TRACE_EVENT0("cobalt::layout", kBenchmarkStatRenderAndAnimate);
diff --git a/src/cobalt/layout/layout.h b/src/cobalt/layout/layout.h
index a777318..678fe54 100644
--- a/src/cobalt/layout/layout.h
+++ b/src/cobalt/layout/layout.h
@@ -38,7 +38,8 @@
// (https://www.w3.org/TR/CSS2/visuren.html) as recommended by a newer draft
// (http://dev.w3.org/csswg/css-box/) which is undergoing active changes.
-// Update the computed styles, then generate and layout the box tree.
+// Update the computed styles, then generate and layout the box tree produced
+// by the given document.
void UpdateComputedStylesAndLayoutBoxTree(
const icu::Locale& locale, const scoped_refptr<dom::Document>& document,
int dom_max_element_depth, UsedStyleProvider* used_style_provider,
@@ -47,15 +48,11 @@
icu::BreakIterator* character_break_iterator,
scoped_refptr<BlockLevelBlockContainerBox>* initial_containing_block);
-// Main entry point to the layout engine.
-// Produces the render tree (along with corresponding animations) which is a
-// result of recursive layout of the given HTML element.
-scoped_refptr<render_tree::Node> Layout(
- const icu::Locale& locale, const scoped_refptr<dom::Document>& document,
- int dom_max_element_depth, UsedStyleProvider* used_style_provider,
+// Generates the render tree (along with corresponding animations) of the box
+// tree contained within the provided containing block.
+scoped_refptr<render_tree::Node> GenerateRenderTreeFromBoxTree(
+ UsedStyleProvider* used_style_provider,
LayoutStatTracker* layout_stat_tracker,
- icu::BreakIterator* line_break_iterator,
- icu::BreakIterator* character_break_iterator,
scoped_refptr<BlockLevelBlockContainerBox>* initial_containing_block);
} // namespace layout
diff --git a/src/cobalt/layout/layout_manager.cc b/src/cobalt/layout/layout_manager.cc
index 0ada5d3..36ddfc8 100644
--- a/src/cobalt/layout/layout_manager.cc
+++ b/src/cobalt/layout/layout_manager.cc
@@ -57,9 +57,10 @@
void Suspend();
void Resume();
- bool IsNewRenderTreePending() const;
+ bool IsRenderTreePending() const;
private:
+ void DirtyLayout();
void StartLayoutTimer();
void DoLayoutAndProduceRenderTree();
@@ -73,11 +74,13 @@
const OnRenderTreeProducedCallback on_render_tree_produced_callback_;
const LayoutTrigger layout_trigger_;
- // This flag indicates whether or not we should do a re-layout. The flag
- // is checked at a regular interval (e.g. 60Hz) and if it is set to true,
- // a layout is initiated and it is set back to false. Events such as
- // DOM mutations will set this flag back to true.
- base::CVal<bool> layout_dirty_;
+ // Setting these flags triggers an update of the layout box tree and the
+ // generation of a new render tree at a regular interval (e.g. 60Hz). Events
+ // such as DOM mutations cause them to be set to true. While the render tree
+ // is excusively produced at the regular interval, the box tree can also be
+ // updated via a call to DoSynchronousLayout().
+ bool are_computed_styles_and_box_tree_dirty_;
+ base::CVal<bool> is_render_tree_pending_;
// Construction of |BreakIterator| requires a disk read, so we cache them
// in the layout manager in order to reuse them with all layouts happening
@@ -106,9 +109,7 @@
void UpdateCamera(
float width_to_height_aspect_ratio, scoped_refptr<dom::Camera3DImpl> camera,
float max_horizontal_fov_rad, float max_vertical_fov_rad,
- render_tree::MatrixTransform3DNode::Builder* transform_node_builder,
- base::TimeDelta time) {
- UNREFERENCED_PARAMETER(time);
+ render_tree::MatrixTransform3DNode::Builder* transform_node_builder) {
transform_node_builder->transform = camera->QueryViewPerspectiveMatrix(
width_to_height_aspect_ratio, max_horizontal_fov_rad,
max_vertical_fov_rad);
@@ -151,9 +152,10 @@
base::Bind(&AttachCameraNodes, window), enable_image_animations)),
on_render_tree_produced_callback_(on_render_tree_produced),
layout_trigger_(layout_trigger),
- layout_dirty_(StringPrintf("%s.Layout.IsDirty", name.c_str()), true,
- "Non-zero when the layout is dirty and a new render tree "
- "is pending."),
+ are_computed_styles_and_box_tree_dirty_(true),
+ is_render_tree_pending_(
+ StringPrintf("%s.Layout.IsRenderTreePending", name.c_str()), true,
+ "Non-zero when a new render tree is pending."),
layout_timer_(true, true, true),
dom_max_element_depth_(dom_max_element_depth),
layout_refresh_rate_(layout_refresh_rate),
@@ -197,7 +199,7 @@
#if defined(ENABLE_TEST_RUNNER)
if (layout_trigger_ == kTestRunnerMode &&
!window_->test_runner()->should_wait()) {
- layout_dirty_ = true;
+ DirtyLayout();
// Run the |DoLayoutAndProduceRenderTree| task after onload event finished.
MessageLoop::current()->PostTask(
@@ -210,7 +212,7 @@
void LayoutManager::Impl::OnMutation() {
if (layout_trigger_ == kOnDocumentMutation) {
- layout_dirty_ = true;
+ DirtyLayout();
}
}
@@ -220,11 +222,14 @@
return;
}
- layout::UpdateComputedStylesAndLayoutBoxTree(
- locale_, window_->document(), dom_max_element_depth_,
- used_style_provider_.get(), layout_stat_tracker_,
- line_break_iterator_.get(), character_break_iterator_.get(),
- &initial_containing_block_);
+ if (are_computed_styles_and_box_tree_dirty_) {
+ layout::UpdateComputedStylesAndLayoutBoxTree(
+ locale_, window_->document(), dom_max_element_depth_,
+ used_style_provider_.get(), layout_stat_tracker_,
+ line_break_iterator_.get(), character_break_iterator_.get(),
+ &initial_containing_block_);
+ are_computed_styles_and_box_tree_dirty_ = false;
+ }
}
void LayoutManager::Impl::Suspend() {
@@ -245,18 +250,18 @@
void LayoutManager::Impl::Resume() {
// Mark that we are no longer suspended and indicate that the layout is
// dirty since when Suspend() was called we invalidated our previous layout.
- layout_dirty_ = true;
+ DirtyLayout();
suspended_ = false;
}
-bool LayoutManager::Impl::IsNewRenderTreePending() const {
- return layout_dirty_;
+bool LayoutManager::Impl::IsRenderTreePending() const {
+ return is_render_tree_pending_;
}
#if defined(ENABLE_TEST_RUNNER)
void LayoutManager::Impl::DoTestRunnerLayoutCallback() {
DCHECK_EQ(kTestRunnerMode, layout_trigger_);
- layout_dirty_ = true;
+ DirtyLayout();
if (layout_trigger_ == kTestRunnerMode &&
window_->test_runner()->should_wait()) {
@@ -272,6 +277,11 @@
}
#endif // ENABLE_TEST_RUNNER
+void LayoutManager::Impl::DirtyLayout() {
+ are_computed_styles_and_box_tree_dirty_ = true;
+ is_render_tree_pending_ = true;
+}
+
void LayoutManager::Impl::StartLayoutTimer() {
// TODO: Eventually we would like to instead base our layouts off of a
// "refresh" signal generated by the rasterizer, instead of trying to
@@ -304,7 +314,7 @@
bool has_layout_processing_started = false;
if (window_->HasPendingAnimationFrameCallbacks()) {
- if (layout_dirty_) {
+ if (are_computed_styles_and_box_tree_dirty_) {
has_layout_processing_started = true;
TRACE_EVENT_BEGIN0("cobalt::layout", kBenchmarkStatLayout);
// Update our computed style before running animation callbacks, so that
@@ -321,7 +331,10 @@
window_->RunAnimationFrameCallbacks();
}
- if (layout_dirty_) {
+ // It should never be possible for for the computed styles and box tree to
+ // be dirty when a render tree is not pending.
+ DCHECK(is_render_tree_pending_ || !are_computed_styles_and_box_tree_dirty_);
+ if (is_render_tree_pending_) {
if (!has_layout_processing_started) {
// We want to catch the beginning of all layout processing. If it didn't
// begin before the call to RunAnimationFrameCallbacks(), then the flow
@@ -329,11 +342,19 @@
TRACE_EVENT_BEGIN0("cobalt::layout", kBenchmarkStatLayout);
}
- scoped_refptr<render_tree::Node> render_tree_root = layout::Layout(
- locale_, window_->document(), dom_max_element_depth_,
- used_style_provider_.get(), layout_stat_tracker_,
- line_break_iterator_.get(), character_break_iterator_.get(),
- &initial_containing_block_);
+ if (are_computed_styles_and_box_tree_dirty_) {
+ layout::UpdateComputedStylesAndLayoutBoxTree(
+ locale_, window_->document(), dom_max_element_depth_,
+ used_style_provider_.get(), layout_stat_tracker_,
+ line_break_iterator_.get(), character_break_iterator_.get(),
+ &initial_containing_block_);
+ are_computed_styles_and_box_tree_dirty_ = false;
+ }
+
+ scoped_refptr<render_tree::Node> render_tree_root =
+ layout::GenerateRenderTreeFromBoxTree(used_style_provider_.get(),
+ layout_stat_tracker_,
+ &initial_containing_block_);
bool run_on_render_tree_produced_callback = true;
#if defined(ENABLE_TEST_RUNNER)
if (layout_trigger_ == kTestRunnerMode &&
@@ -348,8 +369,7 @@
*document->timeline()->current_time())));
}
- layout_dirty_ = false;
-
+ is_render_tree_pending_ = false;
TRACE_EVENT_END0("cobalt::layout", kBenchmarkStatLayout);
}
}
@@ -368,8 +388,8 @@
void LayoutManager::Suspend() { impl_->Suspend(); }
void LayoutManager::Resume() { impl_->Resume(); }
-bool LayoutManager::IsNewRenderTreePending() const {
- return impl_->IsNewRenderTreePending();
+bool LayoutManager::IsRenderTreePending() const {
+ return impl_->IsRenderTreePending();
}
} // namespace layout
diff --git a/src/cobalt/layout/layout_manager.h b/src/cobalt/layout/layout_manager.h
index a2cde5c..799516b 100644
--- a/src/cobalt/layout/layout_manager.h
+++ b/src/cobalt/layout/layout_manager.h
@@ -71,7 +71,7 @@
void Suspend();
void Resume();
- bool IsNewRenderTreePending() const;
+ bool IsRenderTreePending() const;
private:
class Impl;
diff --git a/src/cobalt/layout/replaced_box.cc b/src/cobalt/layout/replaced_box.cc
index 4811118..6cfe7bc 100644
--- a/src/cobalt/layout/replaced_box.cc
+++ b/src/cobalt/layout/replaced_box.cc
@@ -231,9 +231,7 @@
}
void AnimateVideoImage(const ReplacedBox::ReplaceImageCB& replace_image_cb,
- ImageNode::Builder* image_node_builder,
- base::TimeDelta time) {
- UNREFERENCED_PARAMETER(time);
+ ImageNode::Builder* image_node_builder) {
DCHECK(!replace_image_cb.is_null());
DCHECK(image_node_builder);
@@ -250,14 +248,27 @@
void AnimateVideoWithLetterboxing(
const ReplacedBox::ReplaceImageCB& replace_image_cb,
math::SizeF destination_size,
- CompositionNode::Builder* composition_node_builder, base::TimeDelta time) {
- UNREFERENCED_PARAMETER(time);
-
+ CompositionNode::Builder* composition_node_builder) {
DCHECK(!replace_image_cb.is_null());
DCHECK(composition_node_builder);
scoped_refptr<render_tree::Image> image = replace_image_cb.Run();
+ // If the image hasn't changed, then no need to change anything else. The
+ // image should be the first child (see AddLetterboxedImageToRenderTree()).
+ if (!composition_node_builder->children().empty()) {
+ render_tree::ImageNode* existing_image_node =
+ base::polymorphic_downcast<render_tree::ImageNode*>(
+ composition_node_builder->GetChild(0)->get());
+ if (existing_image_node->data().source.get() == image.get()) {
+ return;
+ }
+ }
+
+ // Reset the composition node from whatever it was before; we will recreate
+ // it anew in each animation frame.
+ composition_node_builder->Reset();
+
// TODO: Detect better when the intrinsic video size is used for the
// node size, and trigger a re-layout from the media element when the size
// changes.
diff --git a/src/cobalt/layout_tests/layout_tests.cc b/src/cobalt/layout_tests/layout_tests.cc
index ec0ce07..26b09b7 100644
--- a/src/cobalt/layout_tests/layout_tests.cc
+++ b/src/cobalt/layout_tests/layout_tests.cc
@@ -90,7 +90,7 @@
scoped_refptr<render_tree::animations::AnimateNode> animate_node =
new render_tree::animations::AnimateNode(layout_results.render_tree);
scoped_refptr<render_tree::Node> animated_tree =
- animate_node->Apply(layout_results.layout_time).animated;
+ animate_node->Apply(layout_results.layout_time).animated->source();
bool results =
pixel_tester.TestTree(animated_tree, GetParam().base_file_path);
diff --git a/src/cobalt/loader/image/animated_webp_image.cc b/src/cobalt/loader/image/animated_webp_image.cc
index 123d945..6f12f2d 100644
--- a/src/cobalt/loader/image/animated_webp_image.cc
+++ b/src/cobalt/loader/image/animated_webp_image.cc
@@ -211,6 +211,10 @@
*image_pointer = static_image->image();
}
+void DecodeError(const std::string& error) {
+ LOG(ERROR) << error;
+}
+
} // namespace
bool AnimatedWebPImage::DecodeOneFrame(int frame_index) {
@@ -233,7 +237,7 @@
ImageDecoder image_decoder(
resource_provider_, base::Bind(&RecordImage, &next_frame_image),
- ImageDecoder::ErrorCallback(), ImageDecoder::kImageTypeWebP);
+ base::Bind(&DecodeError), ImageDecoder::kImageTypeWebP);
image_decoder.DecodeChunk(
reinterpret_cast<const char*>(webp_iterator.fragment.bytes),
webp_iterator.fragment.size);
diff --git a/src/cobalt/loader/image/image.h b/src/cobalt/loader/image/image.h
index 2b72010..740c9b5 100644
--- a/src/cobalt/loader/image/image.h
+++ b/src/cobalt/loader/image/image.h
@@ -140,10 +140,7 @@
scoped_refptr<FrameProvider> frame_provider,
const math::RectF& destination_rect,
const math::Matrix3F& local_transform,
- render_tree::ImageNode::Builder* image_node_builder,
- base::TimeDelta time) {
- UNREFERENCED_PARAMETER(time);
-
+ render_tree::ImageNode::Builder* image_node_builder) {
image_node_builder->source = frame_provider->GetFrame();
image_node_builder->destination_rect = destination_rect;
image_node_builder->local_transform = local_transform;
diff --git a/src/cobalt/loader/image/webp_image_decoder.cc b/src/cobalt/loader/image/webp_image_decoder.cc
index 5c803bc..f44986b 100644
--- a/src/cobalt/loader/image/webp_image_decoder.cc
+++ b/src/cobalt/loader/image/webp_image_decoder.cc
@@ -106,6 +106,7 @@
DLOG(ERROR) << "WebPIAppend error, status code: " << status;
DeleteInternalDecoder();
set_state(kError);
+ return 0;
}
} else {
animated_webp_image_->AppendChunk(data, input_byte);
diff --git a/src/cobalt/loader/resource_cache.h b/src/cobalt/loader/resource_cache.h
index 336d137..024cc55 100644
--- a/src/cobalt/loader/resource_cache.h
+++ b/src/cobalt/loader/resource_cache.h
@@ -510,10 +510,14 @@
base::ThreadChecker resource_cache_thread_checker_;
- base::CVal<base::cval::SizeInBytes, base::CValPublic> size_in_bytes_;
- base::CVal<base::cval::SizeInBytes, base::CValPublic> capacity_in_bytes_;
- base::CVal<int> count_requested_resources_;
- base::CVal<int> count_loading_resources_;
+ base::CVal<base::cval::SizeInBytes, base::CValPublic> memory_size_in_bytes_;
+ base::CVal<base::cval::SizeInBytes, base::CValPublic>
+ memory_capacity_in_bytes_;
+ base::CVal<base::cval::SizeInBytes> memory_resources_loaded_in_bytes_;
+
+ base::CVal<int> count_resources_requested_;
+ base::CVal<int> count_resources_loading_;
+ base::CVal<int> count_resources_loaded_;
base::CVal<int> count_pending_callbacks_;
DISALLOW_COPY_AND_ASSIGN(ResourceCache);
@@ -532,20 +536,28 @@
create_loader_function_(create_loader_function),
is_processing_pending_callbacks_(false),
are_callbacks_disabled_(false),
- size_in_bytes_(base::StringPrintf("Memory.%s.Size", name_.c_str()), 0,
- "Total number of bytes currently used by the cache."),
- capacity_in_bytes_(
+ memory_size_in_bytes_(
+ base::StringPrintf("Memory.%s.Size", name_.c_str()), 0,
+ "Total number of bytes currently used by the cache."),
+ memory_capacity_in_bytes_(
base::StringPrintf("Memory.%s.Capacity", name_.c_str()),
cache_capacity_,
"The capacity, in bytes, of the resource cache. "
"Exceeding this results in *unused* resources being "
"purged."),
- count_requested_resources_(
- base::StringPrintf("Count.%s.RequestedResources", name_.c_str()), 0,
+ memory_resources_loaded_in_bytes_(
+ base::StringPrintf("Memory.%s.Resource.Loaded", name_.c_str()), 0,
+ "Combined size in bytes of all resources that have been loaded by "
+ "the cache."),
+ count_resources_requested_(
+ base::StringPrintf("Count.%s.Resource.Requested", name_.c_str()), 0,
"The total number of resources that have been requested."),
- count_loading_resources_(
- base::StringPrintf("Count.%s.LoadingResources", name_.c_str()), 0,
- "The number of loading resources that are still outstanding."),
+ count_resources_loading_(
+ base::StringPrintf("Count.%s.Resource.Loading", name_.c_str()), 0,
+ "The number of resources that are currently loading."),
+ count_resources_loaded_(
+ base::StringPrintf("Count.%s.Resource.Loaded", name_.c_str()), 0,
+ "The total number of resources that have been successfully loaded."),
count_pending_callbacks_(
base::StringPrintf("Count.%s.PendingCallbacks", name_.c_str()), 0,
"The number of loading completed resources that have pending "
@@ -580,7 +592,7 @@
}
// If we reach this point, then the resource doesn't exist yet.
- ++count_requested_resources_;
+ ++count_resources_requested_;
// Add the resource to a loading set. If no current resources have pending
// callbacks, then this resource will block callbacks until it is decoded.
@@ -593,7 +605,7 @@
} else {
non_callback_blocking_loading_resource_set_.insert(url.spec());
}
- ++count_loading_resources_;
+ ++count_resources_loading_;
// Create the cached resource and fetch its resource based on the url.
scoped_refptr<CachedResourceType> cached_resource(new CachedResourceType(
@@ -613,7 +625,7 @@
void ResourceCache<CacheType>::SetCapacity(uint32 capacity) {
DCHECK(resource_cache_thread_checker_.CalledOnValidThread());
cache_capacity_ = capacity;
- capacity_in_bytes_ = capacity;
+ memory_capacity_in_bytes_ = capacity;
ReclaimMemoryAndMaybeProcessPendingCallbacks(cache_capacity_);
}
@@ -637,8 +649,12 @@
const std::string& url = cached_resource->url().spec();
if (cached_resource->TryGetResource()) {
- size_in_bytes_ +=
+ uint32 estimated_size_in_bytes =
CacheType::GetEstimatedSizeInBytes(cached_resource->TryGetResource());
+ memory_size_in_bytes_ += estimated_size_in_bytes;
+ memory_resources_loaded_in_bytes_ += estimated_size_in_bytes;
+
+ ++count_resources_loaded_;
}
// Remove the resource from its loading set. It should exist in exactly one
@@ -659,7 +675,7 @@
// incremented first to ensure that the total of the two counts always remains
// above 0.
++count_pending_callbacks_;
- --count_loading_resources_;
+ --count_resources_loading_;
ProcessPendingCallbacksIfUnblocked();
ReclaimMemoryAndMaybeProcessPendingCallbacks(cache_capacity_);
@@ -690,10 +706,10 @@
DCHECK(non_callback_blocking_loading_resource_set_.find(url) ==
non_callback_blocking_loading_resource_set_.end());
DCHECK(pending_callback_map_.find(url) == pending_callback_map_.end());
- --count_loading_resources_;
+ --count_resources_loading_;
} else if (non_callback_blocking_loading_resource_set_.erase(url)) {
DCHECK(pending_callback_map_.find(url) == pending_callback_map_.end());
- --count_loading_resources_;
+ --count_resources_loading_;
} else if (pending_callback_map_.erase(url)) {
--count_pending_callbacks_;
}
@@ -717,7 +733,7 @@
// pending callbacks and try again. References to the cached resources are
// potentially being held until the callbacks run, so processing them may
// enable more memory to be reclaimed.
- if (size_in_bytes_ > bytes_to_reclaim_down_to) {
+ if (memory_size_in_bytes_ > bytes_to_reclaim_down_to) {
ProcessPendingCallbacks();
ReclaimMemory(bytes_to_reclaim_down_to, true /*log_warning_if_over*/);
}
@@ -728,7 +744,7 @@
bool log_warning_if_over) {
DCHECK(resource_cache_thread_checker_.CalledOnValidThread());
- while (size_in_bytes_ > bytes_to_reclaim_down_to &&
+ while (memory_size_in_bytes_ > bytes_to_reclaim_down_to &&
!unreference_cached_resource_map_.empty()) {
// The first element is the earliest-inserted element.
scoped_refptr<ResourceType> resource =
@@ -739,15 +755,15 @@
// in linked_hash_map. Add that function and related unit test.
unreference_cached_resource_map_.erase(
unreference_cached_resource_map_.begin());
- size_in_bytes_ -= first_resource_size;
+ memory_size_in_bytes_ -= first_resource_size;
}
if (log_warning_if_over) {
// Log a warning if we're still over |bytes_to_reclaim_down_to| after
// attempting to reclaim memory. This can occur validly when the size of
// the referenced images exceeds the target size.
- DLOG_IF(WARNING, size_in_bytes_ > bytes_to_reclaim_down_to)
- << "cached size: " << size_in_bytes_
+ DLOG_IF(WARNING, memory_size_in_bytes_ > bytes_to_reclaim_down_to)
+ << "cached size: " << memory_size_in_bytes_
<< ", target size: " << bytes_to_reclaim_down_to;
}
}
diff --git a/src/cobalt/media/base/sbplayer_pipeline.cc b/src/cobalt/media/base/sbplayer_pipeline.cc
index e783005..95f2b55 100644
--- a/src/cobalt/media/base/sbplayer_pipeline.cc
+++ b/src/cobalt/media/base/sbplayer_pipeline.cc
@@ -653,7 +653,7 @@
void SbPlayerPipeline::OnDemuxerSeeked(PipelineStatus status) {
DCHECK(message_loop_->BelongsToCurrentThread());
- if (status == PIPELINE_OK) {
+ if (status == PIPELINE_OK && player_) {
player_->Seek(seek_time_);
}
}
diff --git a/src/cobalt/render_tree/animations/animate_node.cc b/src/cobalt/render_tree/animations/animate_node.cc
index 58c11b4..dfdc7c1 100644
--- a/src/cobalt/render_tree/animations/animate_node.cc
+++ b/src/cobalt/render_tree/animations/animate_node.cc
@@ -66,7 +66,8 @@
TraverseList* traverse_list)
: animation_map_(animation_map),
traverse_list_(traverse_list),
- expiry_(-base::TimeDelta::Max()) {}
+ expiry_(-base::TimeDelta::Max()),
+ depends_on_time_expiry_(-base::TimeDelta::Max()) {}
void Visit(animations::AnimateNode* animate) OVERRIDE;
void Visit(CompositionNode* composition) OVERRIDE { VisitNode(composition); }
@@ -117,6 +118,10 @@
// The time after which all animations will have completed and be constant.
base::TimeDelta expiry_;
+ // Similar to |expiry_| but accumulated only for animations whose callback
+ // depends on the time parameter.
+ base::TimeDelta depends_on_time_expiry_;
+
friend class AnimateNode;
};
@@ -146,6 +151,9 @@
// Update our expiry in accordance with the sub-AnimateNode's expiry.
expiry_ = std::max(expiry_, animate->expiry());
+
+ depends_on_time_expiry_ =
+ std::max(depends_on_time_expiry_, animate->depends_on_time_expiry());
}
template <typename T>
@@ -208,8 +216,10 @@
void AnimateNode::TraverseListBuilder::AddToTraverseList(
Node* node, AnimateNode::Builder::InternalMap::const_iterator found) {
if (found != animation_map_.end()) {
- traverse_list_->push_back(TraverseListEntry(node, found->second));
+ traverse_list_->push_back(TraverseListEntry(node, found->second, false));
expiry_ = std::max(expiry_, found->second->GetExpiry());
+ depends_on_time_expiry_ = std::max(depends_on_time_expiry_,
+ found->second->GetDependsOnTimeExpiry());
} else {
traverse_list_->push_back(TraverseListEntry(node));
}
@@ -304,7 +314,9 @@
TraverseListEntry current_entry = AdvanceIterator(node);
DCHECK(current_entry.animations);
- ProcessAnimatedNodeBounds(current_entry, node);
+ if (current_entry.did_animate_previously) {
+ ProcessAnimatedNodeBounds(current_entry, node);
+ }
}
template <typename T>
@@ -336,7 +348,7 @@
}
transform_ = old_transform;
- if (current_entry.animations) {
+ if (current_entry.did_animate_previously) {
ProcessAnimatedNodeBounds(current_entry, node);
}
}
@@ -376,7 +388,8 @@
// tree.
class AnimateNode::ApplyVisitor : public NodeVisitor {
public:
- ApplyVisitor(const TraverseList& traverse_list, base::TimeDelta time_offset);
+ ApplyVisitor(const TraverseList& traverse_list, base::TimeDelta time_offset,
+ const base::optional<base::TimeDelta>& snapshot_time);
void Visit(animations::AnimateNode* /* animate */) OVERRIDE {
// An invariant of AnimateNodes is that they should never contain descendant
@@ -405,7 +418,9 @@
// As we compute the animated nodes, we create a new traverse list that leads
// to the newly created animated nodes. This can be used afterwards to
// calculate the bounding boxes around the active animated nodes.
- TraverseList* animated_traverse_list() { return &animated_traverse_list_; }
+ const TraverseList& animated_traverse_list() const {
+ return animated_traverse_list_;
+ }
private:
template <typename T>
@@ -415,8 +430,8 @@
typename base::enable_if<ChildIterator<T>::has_children>::type VisitNode(
T* node);
template <typename T>
- scoped_refptr<Node> ApplyAnimations(const TraverseListEntry& entry,
- typename T::Builder* builder);
+ scoped_refptr<T> ApplyAnimations(const TraverseListEntry& entry,
+ typename T::Builder* builder);
TraverseListEntry AdvanceIterator(Node* node);
// The time offset to be passed in to individual animations.
@@ -435,11 +450,18 @@
// An iterator pointing to the next valid render tree node to visit.
TraverseList::const_iterator iterator_;
+
+ // Time at which the existing source render tree was created/last animated
+ // at.
+ base::optional<base::TimeDelta> snapshot_time_;
};
-AnimateNode::ApplyVisitor::ApplyVisitor(const TraverseList& traverse_list,
- base::TimeDelta time_offset)
- : time_offset_(time_offset), traverse_list_(traverse_list) {
+AnimateNode::ApplyVisitor::ApplyVisitor(
+ const TraverseList& traverse_list, base::TimeDelta time_offset,
+ const base::optional<base::TimeDelta>& snapshot_time)
+ : time_offset_(time_offset),
+ traverse_list_(traverse_list),
+ snapshot_time_(snapshot_time) {
animated_traverse_list_.reserve(traverse_list.size());
iterator_ = traverse_list_.begin();
}
@@ -452,9 +474,18 @@
// have animations.
DCHECK(current_entry.animations);
typename T::Builder builder(node->data());
- animated_ = ApplyAnimations<T>(current_entry, &builder);
+ scoped_refptr<T> animated = ApplyAnimations<T>(current_entry, &builder);
+ // If nothing ends up getting animated, then just re-use the existing node.
+ bool did_animate = false;
+ if (animated->data() == node->data()) {
+ animated_ = node;
+ } else {
+ animated_ = animated.get();
+ did_animate = true;
+ }
+
animated_traverse_list_.push_back(
- TraverseListEntry(animated_, current_entry.animations));
+ TraverseListEntry(animated_, current_entry.animations, did_animate));
}
template <typename T>
@@ -464,7 +495,7 @@
size_t animated_traverse_list_index = animated_traverse_list_.size();
animated_traverse_list_.push_back(
- TraverseListEntry(NULL, current_entry.animations));
+ TraverseListEntry(NULL, current_entry.animations, false));
// Traverse the child nodes, but only the ones that are on the
// |traverse_list_|. In particular, the next node we are allowed to visit
@@ -482,41 +513,60 @@
// If one of our children is next up on the path to animation, traverse
// into it.
child->Accept(this);
- // Traversing into the child means that it was animated, and so replaced
- // by an animated node while it was visited. Thus, replace it in the
- // current node's child list with its animated version.
- child_iterator.ReplaceCurrent(animated_);
- children_modified = true;
+ if (animated_ != child) {
+ // Traversing into the child and seeing |animated_| emerge from the
+ // traversal equal to something other than |child| means that the child
+ // was animated, and so replaced by an animated node while it was
+ // visited. Thus, replace it in the current node's child list with its
+ // animated version.
+ child_iterator.ReplaceCurrent(animated_);
+ children_modified = true;
+ }
}
child_iterator.Next();
}
+ base::optional<typename T::Builder> builder;
+ if (children_modified) {
+ // Reuse the modified Builder object from child traversal if one of
+ // our children was animated.
+ builder.emplace(child_iterator.TakeReplacedChildrenBuilder());
+ }
+
+ bool did_animate = false;
if (current_entry.animations) {
- base::optional<typename T::Builder> builder;
- if (children_modified) {
- // Reuse the modified Builder object from child traversal if one of
- // our children was animated.
- builder.emplace(child_iterator.TakeReplacedChildrenBuilder());
- } else {
+ if (!builder) {
// Create a fresh copy of the Builder object for this animated node, to
// be passed into the animations.
builder.emplace(node->data());
}
- animated_ = ApplyAnimations<T>(current_entry, &(*builder));
+ typename T::Builder original_builder(*builder);
+ scoped_refptr<T> animated = ApplyAnimations<T>(current_entry, &(*builder));
+ if (!(original_builder == *builder)) {
+ did_animate = true;
+ }
+ // If the data didn't actually change, then no animation took place and
+ // so we should note this by not modifying the original render tree node.
+ animated_ = animated->data() == node->data() ? node : animated.get();
} else {
- // If there were no animations targeting this node directly, then its
- // children must have been modified since otherwise it wouldn't be in
- // the traverse list.
- DCHECK(children_modified);
- animated_ = new T(child_iterator.TakeReplacedChildrenBuilder());
+ // If there were no animations targeting this node directly, it may still
+ // need to be animated if its children are animated, which will be the
+ // case if |builder| is populated.
+ if (builder) {
+ animated_ = new T(*builder);
+ } else {
+ animated_ = node;
+ }
}
animated_traverse_list_[animated_traverse_list_index].node = animated_;
+ animated_traverse_list_[animated_traverse_list_index].did_animate_previously =
+ did_animate;
}
template <typename T>
-scoped_refptr<Node> AnimateNode::ApplyVisitor::ApplyAnimations(
+scoped_refptr<T> AnimateNode::ApplyVisitor::ApplyAnimations(
const TraverseListEntry& entry, typename T::Builder* builder) {
TRACE_EVENT0("cobalt::renderer",
"AnimateNode::ApplyVisitor::ApplyAnimations()");
@@ -525,11 +575,16 @@
base::polymorphic_downcast<const AnimationList<T>*>(
entry.animations.get());
- // Iterate through each animation applying them one at a time.
- for (typename AnimationList<T>::InternalList::const_iterator iter =
- typed_node_animations->data().animations.begin();
- iter != typed_node_animations->data().animations.end(); ++iter) {
- iter->Run(builder, time_offset_);
+ // Only execute the animation updates on nodes that have not expired.
+ if (!snapshot_time_ ||
+ typed_node_animations->data().expiry >= *snapshot_time_) {
+ TRACE_EVENT0("cobalt::renderer", "Running animation callbacks");
+ // Iterate through each animation applying them one at a time.
+ for (typename AnimationList<T>::InternalList::const_iterator iter =
+ typed_node_animations->data().animations.begin();
+ iter != typed_node_animations->data().animations.end(); ++iter) {
+ iter->Run(builder, time_offset_);
+ }
}
return new T(*builder);
@@ -559,9 +614,9 @@
class AnimateNode::RefCountedTraversalList
: public base::RefCounted<RefCountedTraversalList> {
public:
- explicit RefCountedTraversalList(TraverseList* to_swap_in) {
- traverse_list_.swap(*to_swap_in);
- }
+ explicit RefCountedTraversalList(const TraverseList& traverse_list)
+ : traverse_list_(traverse_list) {}
+
const TraverseList& traverse_list() const { return traverse_list_; }
private:
@@ -594,24 +649,41 @@
AnimateNode::AnimateResults AnimateNode::Apply(base::TimeDelta time_offset) {
TRACE_EVENT0("cobalt::renderer", "AnimateNode::Apply()");
+ if (snapshot_time_) {
+ // Assume we are always animating forward.
+ DCHECK_LE(*snapshot_time_, time_offset);
+ }
+
AnimateResults results;
if (traverse_list_.empty()) {
- results.animated = source_;
+ results.animated = this;
// There are no animations, so there is no bounding rectangle, so setup the
// bounding box function to trivially return an empty rectangle.
results.get_animation_bounds_since =
base::Bind(&ReturnTrivialEmptyRectBound);
} else {
- ApplyVisitor apply_visitor(traverse_list_, time_offset);
+ ApplyVisitor apply_visitor(traverse_list_, time_offset, snapshot_time_);
source_->Accept(&apply_visitor);
- results.animated = apply_visitor.animated();
- // Setup a function for returning
+ // Setup a function for returning the bounds on the regions modified by
+ // animations given a specific starting point in time ("since"). This
+ // can be used by rasterizers to determine which regions need to be
+ // re-drawn or not.
results.get_animation_bounds_since = base::Bind(
&GetAnimationBoundsSince,
scoped_refptr<RefCountedTraversalList>(new RefCountedTraversalList(
apply_visitor.animated_traverse_list())),
- time_offset, results.animated);
+ time_offset, apply_visitor.animated());
+
+ if (apply_visitor.animated() == source()) {
+ // If no animations were actually applied, indicate this by returning
+ // this exact node as the animated node.
+ results.animated = this;
+ } else {
+ results.animated = new AnimateNode(apply_visitor.animated_traverse_list(),
+ apply_visitor.animated(), expiry_,
+ depends_on_time_expiry_, time_offset);
+ }
}
return results;
}
@@ -638,6 +710,7 @@
}
expiry_ = traverse_list_builder.expiry_;
+ depends_on_time_expiry_ = traverse_list_builder.depends_on_time_expiry_;
}
} // namespace animations
diff --git a/src/cobalt/render_tree/animations/animate_node.h b/src/cobalt/render_tree/animations/animate_node.h
index 70ed9ba..c71e620 100644
--- a/src/cobalt/render_tree/animations/animate_node.h
+++ b/src/cobalt/render_tree/animations/animate_node.h
@@ -20,6 +20,7 @@
#include "base/containers/small_map.h"
#include "base/memory/ref_counted.h"
+#include "base/optional.h"
#include "cobalt/math/rect_f.h"
#include "cobalt/render_tree/animations/animation_list.h"
#include "cobalt/render_tree/movable.h"
@@ -80,12 +81,30 @@
}
template <typename T>
+ void Add(
+ const scoped_refptr<T>& target_node,
+ const typename Animation<T>::TimeIndependentFunction& single_animation,
+ base::TimeDelta expiry) {
+ AddInternal(target_node,
+ scoped_refptr<AnimationListBase>(
+ new AnimationList<T>(single_animation, expiry)));
+ }
+
+ template <typename T>
void Add(const scoped_refptr<T>& target_node,
const typename Animation<T>::Function& single_animation) {
AddInternal(target_node,
scoped_refptr<AnimationListBase>(new AnimationList<T>(
single_animation, base::TimeDelta::Max())));
}
+ template <typename T>
+ void Add(const scoped_refptr<T>& target_node,
+ const typename Animation<T>::TimeIndependentFunction&
+ single_animation) {
+ AddInternal(target_node,
+ scoped_refptr<AnimationListBase>(new AnimationList<T>(
+ single_animation, base::TimeDelta::Max())));
+ }
// Merge all mappings from another AnimateNode::Builder into this one.
// There cannot be any keys that are in both the merge target and source.
@@ -140,8 +159,11 @@
struct AnimateResults {
// The animated render tree, which is guaranteed to not contain any
- // AnimateNodes.
- scoped_refptr<Node> animated;
+ // AnimateNodes. Note that it is returned as an AnimateNode... The actual
+ // animated render tree can be obtained via |animated->source()|, the
+ // AnimateNode however allows one to animate the animated node so that
+ // it can be checked if anything has actually been animated or not.
+ scoped_refptr<AnimateNode> animated;
// Can be called in order to return a bounding rectangle around all
// nodes that are actively animated. The parameter specifies a "since"
@@ -152,6 +174,9 @@
base::Callback<math::RectF(base::TimeDelta)> get_animation_bounds_since;
};
// Apply the animations to the sub render tree with the given |time_offset|.
+ // Note that if |animated| in the results is equivalent to |this| on which
+ // Apply() is called, then no animations have actually taken place, and a
+ // re-render can be avoided.
AnimateResults Apply(base::TimeDelta time_offset);
// Returns the sub-tree for which the animations apply to.
@@ -163,6 +188,12 @@
// all x, y >= expiry().
const base::TimeDelta& expiry() const { return expiry_; }
+ // Similar to |expiry()|, but returns the expiration for all animations whose
+ // callback function actually depends on the time parameter passed into them.
+ const base::TimeDelta& depends_on_time_expiry() const {
+ return depends_on_time_expiry_;
+ }
+
private:
// The compiled node animation list is a sequence of nodes that are either
// animated themselves, or on the path to an animated node. Only nodes in
@@ -170,12 +201,19 @@
// list, complete with animations to be applied to the given node, if any.
struct TraverseListEntry {
TraverseListEntry(Node* node,
- const scoped_refptr<AnimationListBase>& animations)
- : node(node), animations(animations) {}
- explicit TraverseListEntry(Node* node) : node(node) {}
+ const scoped_refptr<AnimationListBase>& animations,
+ bool did_animate_previously)
+ : node(node),
+ animations(animations),
+ did_animate_previously(did_animate_previously) {}
+ explicit TraverseListEntry(Node* node)
+ : node(node), did_animate_previously(false) {}
Node* node;
scoped_refptr<AnimationListBase> animations;
+ // Used when checking animation bounds to see which nodes were actually
+ // animated and whose bounds we need to accumulate.
+ bool did_animate_previously;
};
typedef std::vector<TraverseListEntry> TraverseList;
@@ -192,6 +230,18 @@
// rectangle for all active animations.
class BoundsVisitor;
+ // This private constructor is used by AnimateNode::Apply() to create a new
+ // AnimateNode that matches the resulting animated render tree.
+ AnimateNode(const TraverseList& traverse_list, scoped_refptr<Node> source,
+ const base::TimeDelta& expiry,
+ const base::TimeDelta& depends_on_time_expiry,
+ const base::TimeDelta& snapshot_time)
+ : traverse_list_(traverse_list),
+ source_(source),
+ expiry_(expiry),
+ depends_on_time_expiry_(depends_on_time_expiry),
+ snapshot_time_(snapshot_time) {}
+
void CommonInit(const Builder::InternalMap& node_animation_map,
const scoped_refptr<Node>& source);
@@ -205,6 +255,12 @@
TraverseList traverse_list_;
scoped_refptr<Node> source_;
base::TimeDelta expiry_;
+ base::TimeDelta depends_on_time_expiry_;
+ // Time when the |source_| render tree was last animated, if known. This
+ // will get set when Apply() is called to produce a new AnimateNode that can
+ // then be Apply()d again. It can be used during the second apply to check
+ // if some animations have expired.
+ base::optional<base::TimeDelta> snapshot_time_;
};
} // namespace animations
diff --git a/src/cobalt/render_tree/animations/animate_node_test.cc b/src/cobalt/render_tree/animations/animate_node_test.cc
index 7f539b9..b19733e 100644
--- a/src/cobalt/render_tree/animations/animate_node_test.cc
+++ b/src/cobalt/render_tree/animations/animate_node_test.cc
@@ -81,10 +81,10 @@
scoped_refptr<AnimateNode> with_animations =
CreateSingleAnimation(text_node, base::Bind(&AnimateText));
- scoped_refptr<Node> animated_render_tree =
+ scoped_refptr<AnimateNode> animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(1)).animated;
TextNode* animated_text_node =
- dynamic_cast<TextNode*>(animated_render_tree.get());
+ dynamic_cast<TextNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_text_node);
EXPECT_EQ(ColorRGBA(.5f, .5f, .5f), animated_text_node->data().color);
}
@@ -101,10 +101,10 @@
scoped_refptr<AnimateNode> with_animations =
CreateSingleAnimation(image_node, base::Bind(&AnimateImage));
- scoped_refptr<Node> animated_render_tree =
+ scoped_refptr<AnimateNode> animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(1)).animated;
ImageNode* animated_image_node =
- dynamic_cast<ImageNode*>(animated_render_tree.get());
+ dynamic_cast<ImageNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_image_node);
EXPECT_TRUE(animated_image_node);
EXPECT_EQ(RectF(2.0f, 2.0f), animated_image_node->data().destination_rect);
@@ -122,10 +122,10 @@
scoped_refptr<AnimateNode> with_animations =
CreateSingleAnimation(rect_node, base::Bind(&AnimateRect));
- scoped_refptr<Node> animated_render_tree =
+ scoped_refptr<AnimateNode> animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(1)).animated;
RectNode* animated_rect_node =
- dynamic_cast<RectNode*>(animated_render_tree.get());
+ dynamic_cast<RectNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_rect_node);
EXPECT_TRUE(animated_rect_node);
EXPECT_EQ(RectF(2.0f, 2.0f), animated_rect_node->data().rect);
@@ -147,26 +147,29 @@
scoped_refptr<AnimateNode> with_animations =
CreateSingleAnimation(image_node, base::Bind(&AnimateImageAddWithTime));
- scoped_refptr<Node> animated_render_tree;
+ scoped_refptr<AnimateNode> animated_render_tree;
ImageNode* animated_image_node;
animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(1)).animated;
- animated_image_node = dynamic_cast<ImageNode*>(animated_render_tree.get());
+ animated_image_node =
+ dynamic_cast<ImageNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_image_node);
EXPECT_TRUE(animated_image_node);
EXPECT_FLOAT_EQ(3.0f, animated_image_node->data().destination_rect.width());
animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(2)).animated;
- animated_image_node = dynamic_cast<ImageNode*>(animated_render_tree.get());
+ animated_image_node =
+ dynamic_cast<ImageNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_image_node);
EXPECT_TRUE(animated_image_node);
EXPECT_FLOAT_EQ(5.0f, animated_image_node->data().destination_rect.width());
animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(4)).animated;
- animated_image_node = dynamic_cast<ImageNode*>(animated_render_tree.get());
+ animated_image_node =
+ dynamic_cast<ImageNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_image_node);
EXPECT_TRUE(animated_image_node);
EXPECT_FLOAT_EQ(9.0f, animated_image_node->data().destination_rect.width());
@@ -202,11 +205,11 @@
scoped_refptr<AnimateNode> with_animations(
new AnimateNode(animations_builder, image_node));
- scoped_refptr<Node> animated_render_tree =
+ scoped_refptr<AnimateNode> animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(3)).animated;
ImageNode* animated_image_node =
- dynamic_cast<ImageNode*>(animated_render_tree.get());
+ dynamic_cast<ImageNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_image_node);
EXPECT_FLOAT_EQ(21.0f, animated_image_node->data().destination_rect.width());
@@ -228,11 +231,11 @@
scoped_refptr<AnimateNode> with_animations =
CreateSingleAnimation(transform_node, base::Bind(&AnimateTransform));
- scoped_refptr<Node> animated_render_tree =
+ scoped_refptr<AnimateNode> animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(1)).animated;
MatrixTransformNode* animated_transform_node =
- dynamic_cast<MatrixTransformNode*>(animated_render_tree.get());
+ dynamic_cast<MatrixTransformNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_transform_node);
EXPECT_EQ(math::TranslateMatrix(2.0f, 2.0f),
@@ -260,11 +263,11 @@
scoped_refptr<AnimateNode> with_animations =
new AnimateNode(animation_builder, composition_node);
- scoped_refptr<Node> animated_render_tree =
+ scoped_refptr<AnimateNode> animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(1)).animated;
CompositionNode* animated_composition_node =
- dynamic_cast<CompositionNode*>(animated_render_tree.get());
+ dynamic_cast<CompositionNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_composition_node);
ImageNode* animated_image_node_a = dynamic_cast<ImageNode*>(
@@ -291,11 +294,11 @@
scoped_refptr<AnimateNode> with_animations =
CreateSingleAnimation(transform_node, base::Bind(&AnimateTransform));
- scoped_refptr<Node> animated_render_tree =
+ scoped_refptr<AnimateNode> animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(1)).animated;
MatrixTransformNode* animated_transform_node =
- dynamic_cast<MatrixTransformNode*>(animated_render_tree.get());
+ dynamic_cast<MatrixTransformNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_transform_node);
// Check that the matrix transform node is animated.
@@ -328,11 +331,11 @@
scoped_refptr<AnimateNode> with_animations =
new AnimateNode(transform_node_b);
- scoped_refptr<Node> animated_render_tree =
+ scoped_refptr<AnimateNode> animated_render_tree =
with_animations->Apply(base::TimeDelta::FromSeconds(1)).animated;
MatrixTransformNode* animated_transform_node =
- dynamic_cast<MatrixTransformNode*>(animated_render_tree.get());
+ dynamic_cast<MatrixTransformNode*>(animated_render_tree->source().get());
EXPECT_TRUE(animated_transform_node);
// Check that the image node is animated.
diff --git a/src/cobalt/render_tree/animations/animation_list.h b/src/cobalt/render_tree/animations/animation_list.h
index 78f1e65..b51144d 100644
--- a/src/cobalt/render_tree/animations/animation_list.h
+++ b/src/cobalt/render_tree/animations/animation_list.h
@@ -17,6 +17,7 @@
#include <list>
+#include "base/bind.h"
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/time.h"
@@ -68,6 +69,16 @@
// and ultimately add that to a AnimateNode::Builder object so that it can be
// mapped to a specific TextNode that it should be applied to.
typedef base::Callback<void(typename T::Builder*, base::TimeDelta)> Function;
+ typedef base::Callback<void(typename T::Builder*)> TimeIndependentFunction;
+
+ // Helper function to convert from time independent function to a time
+ // dependent function.
+ static void CallTimeIndependentFunction(
+ const TimeIndependentFunction& time_independent_function,
+ typename T::Builder* builder, base::TimeDelta time) {
+ UNREFERENCED_PARAMETER(time);
+ time_independent_function.Run(builder);
+ }
};
// The AnimationListBase is used so that we can acquire a non-template handle
@@ -77,6 +88,7 @@
class AnimationListBase : public base::RefCountedThreadSafe<AnimationListBase> {
public:
virtual base::TimeDelta GetExpiry() const = 0;
+ virtual base::TimeDelta GetDependsOnTimeExpiry() const = 0;
protected:
virtual ~AnimationListBase() {}
@@ -100,18 +112,36 @@
struct Builder {
DECLARE_AS_MOVABLE(Builder);
- Builder() : expiry(base::TimeDelta::Max()) {}
+ Builder() : expiry(base::TimeDelta::Max()),
+ depends_on_time_expiry(base::TimeDelta::Max()) {}
explicit Builder(Moved moved) { animations.swap(moved->animations); }
explicit Builder(const typename Animation<T>::Function& single_animation,
base::TimeDelta expiry)
- : expiry(expiry) {
+ : expiry(expiry), depends_on_time_expiry(expiry) {
animations.push_back(single_animation);
}
+ explicit Builder(
+ const typename Animation<T>::TimeIndependentFunction& single_animation,
+ base::TimeDelta expiry)
+ : expiry(expiry),
+ // Since this animation is time independent, we mark its
+ // time-dependent expiration to be already expired.
+ depends_on_time_expiry(-base::TimeDelta::Max()) {
+ // Transform from a time independent function to a time dependent
+ // function, since we store all functions as time dependent functions.
+ animations.push_back(base::Bind(Animation<T>::CallTimeIndependentFunction,
+ single_animation));
+ }
InternalList animations;
// When do the animations expire? base::TimeDelta::Max() implies that they
// never expire.
base::TimeDelta expiry;
+
+ // Similar to |expiry|, but only set for animations that depend on the
+ // time parameter passed into their animation callback functions.
+ // Optimizations can be performed for animations that don't depend on this.
+ base::TimeDelta depends_on_time_expiry;
};
explicit AnimationList(typename Builder::Moved builder) : data_(builder) {}
@@ -122,10 +152,17 @@
const typename Animation<T>::Function& single_animation,
base::TimeDelta expiry)
: data_(single_animation, expiry) {}
+ explicit AnimationList(
+ const typename Animation<T>::TimeIndependentFunction& single_animation,
+ base::TimeDelta expiry)
+ : data_(single_animation, expiry) {}
const Builder& data() const { return data_; }
base::TimeDelta GetExpiry() const OVERRIDE { return data_.expiry; }
+ base::TimeDelta GetDependsOnTimeExpiry() const OVERRIDE {
+ return data_.depends_on_time_expiry;
+ }
private:
~AnimationList() OVERRIDE {}
diff --git a/src/cobalt/render_tree/blur_filter.h b/src/cobalt/render_tree/blur_filter.h
index 5f6fbe7..cbe95a0 100644
--- a/src/cobalt/render_tree/blur_filter.h
+++ b/src/cobalt/render_tree/blur_filter.h
@@ -29,6 +29,10 @@
// |blur_sigma| must be non-negative.
explicit BlurFilter(float blur_sigma) { set_blur_sigma(blur_sigma); }
+ bool operator==(const BlurFilter& other) const {
+ return blur_sigma_ == other.blur_sigma_;
+ }
+
void set_blur_sigma(float blur_sigma) {
DCHECK_LE(0.0f, blur_sigma);
blur_sigma_ = blur_sigma;
diff --git a/src/cobalt/render_tree/border.h b/src/cobalt/render_tree/border.h
index 761c99f..9b72706 100644
--- a/src/cobalt/render_tree/border.h
+++ b/src/cobalt/render_tree/border.h
@@ -53,6 +53,11 @@
Border(const BorderSide& left, const BorderSide& right, const BorderSide& top,
const BorderSide& bottom);
+ bool operator==(const Border& other) const {
+ return left == other.left && right == other.right && top == other.top &&
+ bottom == other.bottom;
+ }
+
BorderSide left;
BorderSide right;
BorderSide top;
diff --git a/src/cobalt/render_tree/brush.h b/src/cobalt/render_tree/brush.h
index fba8063..988e470 100644
--- a/src/cobalt/render_tree/brush.h
+++ b/src/cobalt/render_tree/brush.h
@@ -45,6 +45,10 @@
public:
explicit SolidColorBrush(const ColorRGBA& color) : color_(color) {}
+ bool operator==(const SolidColorBrush& other) const {
+ return color_ == other.color_;
+ }
+
// A type-safe branching.
void Accept(BrushVisitor* visitor) const OVERRIDE;
@@ -68,6 +72,10 @@
ColorStop(float position, const ColorRGBA& color)
: position(position), color(color) {}
+ bool operator==(const ColorStop& other) const {
+ return position == other.position && color == other.color;
+ }
+
float position;
ColorRGBA color;
};
@@ -102,12 +110,20 @@
const ColorRGBA& source_color,
const ColorRGBA& dest_color);
+ bool operator==(const LinearGradientBrush& other) const {
+ return data_ == other.data_;
+ }
+
struct Data {
Data();
Data(const math::PointF& source, const math::PointF& dest,
const ColorStopList& color_stops);
Data(const math::PointF& source, const math::PointF& dest);
+ bool operator==(const Data& other) const {
+ return source_ == other.source_ && dest_ == other.dest_ &&
+ color_stops_ == other.color_stops_;
+ }
math::PointF source_;
math::PointF dest_;
@@ -167,6 +183,11 @@
float radius_y, const ColorRGBA& source_color,
const ColorRGBA& dest_color);
+ bool operator==(const RadialGradientBrush& other) const {
+ return center_ == other.center_ && radius_x_ == other.radius_x_ &&
+ radius_y_ == other.radius_y_ && color_stops_ == other.color_stops_;
+ }
+
// A type-safe branching.
void Accept(BrushVisitor* visitor) const OVERRIDE;
@@ -192,6 +213,36 @@
scoped_ptr<Brush> CloneBrush(const Brush* brush);
+class EqualsBrushVisitor : public BrushVisitor {
+ public:
+ explicit EqualsBrushVisitor(Brush* brush_a)
+ : brush_a_(brush_a), result_(false) {}
+
+ bool result() const { return result_; }
+
+ void Visit(const SolidColorBrush* solid_color_brush) OVERRIDE {
+ result_ =
+ brush_a_->GetTypeId() == base::GetTypeId<SolidColorBrush>() &&
+ *static_cast<const SolidColorBrush*>(brush_a_) == *solid_color_brush;
+ }
+
+ void Visit(const LinearGradientBrush* linear_gradient_brush) OVERRIDE {
+ result_ = brush_a_->GetTypeId() == base::GetTypeId<LinearGradientBrush>() &&
+ *static_cast<const LinearGradientBrush*>(brush_a_) ==
+ *linear_gradient_brush;
+ }
+
+ void Visit(const RadialGradientBrush* radial_gradient_brush) OVERRIDE {
+ result_ = brush_a_->GetTypeId() == base::GetTypeId<RadialGradientBrush>() &&
+ *static_cast<const RadialGradientBrush*>(brush_a_) ==
+ *radial_gradient_brush;
+ }
+
+ private:
+ Brush* brush_a_;
+ bool result_;
+};
+
} // namespace render_tree
} // namespace cobalt
diff --git a/src/cobalt/render_tree/composition_node.h b/src/cobalt/render_tree/composition_node.h
index 2614822..01d1296 100644
--- a/src/cobalt/render_tree/composition_node.h
+++ b/src/cobalt/render_tree/composition_node.h
@@ -72,6 +72,10 @@
children_.swap(moved->children_);
}
+ bool operator==(const Builder& other) const {
+ return offset_ == other.offset_ && children_ == other.children_;
+ }
+
// Add a child node to the list of children we are building. When a
// CompositionNode is constructed from this CompositionNode::Builder, it
// will have as children all nodes who were passed into the builder via this
@@ -94,6 +98,11 @@
const math::Vector2dF& offset() const { return offset_; }
void set_offset(const math::Vector2dF& offset) { offset_ = offset; }
+ void Reset() {
+ offset_ = math::Vector2dF();
+ ClearChildren();
+ }
+
private:
// A translation offset to be applied to each member of this composition
// node.
diff --git a/src/cobalt/render_tree/filter_node.h b/src/cobalt/render_tree/filter_node.h
index 5ba8ac7..820f31e 100644
--- a/src/cobalt/render_tree/filter_node.h
+++ b/src/cobalt/render_tree/filter_node.h
@@ -51,6 +51,13 @@
math::RectF GetBounds() const;
+ bool operator==(const Builder& other) const {
+ return source == other.source && opacity_filter == other.opacity_filter &&
+ viewport_filter == other.viewport_filter &&
+ blur_filter == other.blur_filter &&
+ map_to_mesh_filter == other.map_to_mesh_filter;
+ }
+
// The source tree, which will be used as the input to the filters specified
// in this FilterNode.
scoped_refptr<render_tree::Node> source;
diff --git a/src/cobalt/render_tree/image_node.h b/src/cobalt/render_tree/image_node.h
index ccd4773..7b5f048 100644
--- a/src/cobalt/render_tree/image_node.h
+++ b/src/cobalt/render_tree/image_node.h
@@ -36,6 +36,12 @@
const math::RectF& destination_rect,
const math::Matrix3F& local_transform);
+ bool operator==(const Builder& other) const {
+ return source == other.source &&
+ destination_rect == other.destination_rect &&
+ local_transform == other.local_transform;
+ }
+
// A source of pixels. May be smaller or larger than layed out image.
// The class does not own the image, it merely refers it from a resource
// pool.
diff --git a/src/cobalt/render_tree/map_to_mesh_filter.h b/src/cobalt/render_tree/map_to_mesh_filter.h
index 2c126e6..bbe4587 100644
--- a/src/cobalt/render_tree/map_to_mesh_filter.h
+++ b/src/cobalt/render_tree/map_to_mesh_filter.h
@@ -47,6 +47,12 @@
public:
struct Builder {
Builder() {}
+ bool operator==(const Builder& other) const {
+ return resolution_matched_meshes_ == other.resolution_matched_meshes_ &&
+ left_eye_default_mesh_ == other.left_eye_default_mesh_ &&
+ right_eye_default_mesh_ == other.right_eye_default_mesh_;
+ }
+
void SetDefaultMeshes(
const scoped_refptr<render_tree::Mesh>& left_eye_mesh,
const scoped_refptr<render_tree::Mesh>& right_eye_mesh) {
@@ -106,6 +112,10 @@
}
}
+ bool operator==(const MapToMeshFilter& other) const {
+ return stereo_mode_ == other.stereo_mode_ && data_ == other.data_;
+ }
+
StereoMode stereo_mode() const { return stereo_mode_; }
// The omission of the |resolution| parameter will yield the default
diff --git a/src/cobalt/render_tree/matrix_transform_3d_node.h b/src/cobalt/render_tree/matrix_transform_3d_node.h
index bbb517a..3732b68 100644
--- a/src/cobalt/render_tree/matrix_transform_3d_node.h
+++ b/src/cobalt/render_tree/matrix_transform_3d_node.h
@@ -37,6 +37,10 @@
Builder(const scoped_refptr<Node>& source, const glm::mat4& transform)
: source(source), transform(transform) {}
+ bool operator==(const Builder& other) const {
+ return source == other.source && transform == other.transform;
+ }
+
// The subtree that will be rendered with |transform| applied to it.
scoped_refptr<Node> source;
diff --git a/src/cobalt/render_tree/matrix_transform_node.h b/src/cobalt/render_tree/matrix_transform_node.h
index 3baafcc..93d9685 100644
--- a/src/cobalt/render_tree/matrix_transform_node.h
+++ b/src/cobalt/render_tree/matrix_transform_node.h
@@ -34,6 +34,10 @@
Builder(const scoped_refptr<Node>& source, const math::Matrix3F& transform)
: source(source), transform(transform) {}
+ bool operator==(const Builder& other) const {
+ return source == other.source && transform == other.transform;
+ }
+
// The subtree that will be rendered with |transform| applied to it.
scoped_refptr<Node> source;
diff --git a/src/cobalt/render_tree/opacity_filter.h b/src/cobalt/render_tree/opacity_filter.h
index 93e8718..113c909 100644
--- a/src/cobalt/render_tree/opacity_filter.h
+++ b/src/cobalt/render_tree/opacity_filter.h
@@ -27,6 +27,10 @@
public:
explicit OpacityFilter(float opacity) { set_opacity(opacity); }
+ bool operator==(const OpacityFilter& other) const {
+ return opacity_ == other.opacity_;
+ }
+
void set_opacity(float opacity) {
DCHECK_LE(0.0f, opacity);
DCHECK_GE(1.0f, opacity);
diff --git a/src/cobalt/render_tree/punch_through_video_node.h b/src/cobalt/render_tree/punch_through_video_node.h
index 3683d6a..f96da9a 100644
--- a/src/cobalt/render_tree/punch_through_video_node.h
+++ b/src/cobalt/render_tree/punch_through_video_node.h
@@ -45,6 +45,10 @@
Builder(const math::RectF& rect, const SetBoundsCB& set_bounds_cb)
: rect(rect), set_bounds_cb(set_bounds_cb) {}
+ bool operator==(const Builder& other) const {
+ return rect == other.rect && set_bounds_cb.Equals(other.set_bounds_cb);
+ }
+
// The destination rectangle (size includes border).
math::RectF rect;
const SetBoundsCB set_bounds_cb;
diff --git a/src/cobalt/render_tree/rect_node.cc b/src/cobalt/render_tree/rect_node.cc
index 7b6f656..33a7ad3 100644
--- a/src/cobalt/render_tree/rect_node.cc
+++ b/src/cobalt/render_tree/rect_node.cc
@@ -84,6 +84,23 @@
border(moved->border.Pass()),
rounded_corners(moved->rounded_corners.Pass()) {}
+bool RectNode::Builder::operator==(const Builder& other) const {
+ bool brush_equals = !background_brush && !other.background_brush;
+ if (background_brush && other.background_brush) {
+ EqualsBrushVisitor brush_equals_visitor(background_brush.get());
+ other.background_brush->Accept(&brush_equals_visitor);
+ brush_equals = brush_equals_visitor.result();
+ }
+ bool border_equals = (!border && !other.border) ||
+ (border && other.border && *border == *other.border);
+ bool rounded_corners_equals = (!rounded_corners && !other.rounded_corners) ||
+ (rounded_corners && other.rounded_corners &&
+ *rounded_corners == *other.rounded_corners);
+
+ return rect == other.rect && brush_equals && border_equals &&
+ rounded_corners_equals;
+}
+
void RectNode::Accept(NodeVisitor* visitor) { visitor->Visit(this); }
math::RectF RectNode::GetBounds() const { return data_.rect; }
diff --git a/src/cobalt/render_tree/rect_node.h b/src/cobalt/render_tree/rect_node.h
index d896aef..13ab23a 100644
--- a/src/cobalt/render_tree/rect_node.h
+++ b/src/cobalt/render_tree/rect_node.h
@@ -52,6 +52,8 @@
explicit Builder(const Builder& other);
explicit Builder(Moved moved);
+ bool operator==(const Builder& other) const;
+
// The destination rectangle (size includes border).
math::RectF rect;
diff --git a/src/cobalt/render_tree/rect_shadow_node.h b/src/cobalt/render_tree/rect_shadow_node.h
index 22344ad..de752f5 100644
--- a/src/cobalt/render_tree/rect_shadow_node.h
+++ b/src/cobalt/render_tree/rect_shadow_node.h
@@ -38,6 +38,11 @@
float spread)
: rect(rect), shadow(shadow), inset(inset), spread(spread) {}
+ bool operator==(const Builder& other) const {
+ return rect == other.rect && rounded_corners == other.rounded_corners &&
+ shadow == other.shadow && inset == other.inset &&
+ spread == other.spread;
+ }
// The destination rectangle.
math::RectF rect;
diff --git a/src/cobalt/render_tree/rounded_corners.h b/src/cobalt/render_tree/rounded_corners.h
index cb630e8..19d1f4c 100644
--- a/src/cobalt/render_tree/rounded_corners.h
+++ b/src/cobalt/render_tree/rounded_corners.h
@@ -80,6 +80,12 @@
bottom_right(bottom_right),
bottom_left(bottom_left) {}
+ bool operator==(const RoundedCorners& other) const {
+ return top_left == other.top_left && top_right == other.top_right &&
+ bottom_right == other.bottom_right &&
+ bottom_left == other.bottom_left;
+ }
+
RoundedCorners Inset(float left, float top, float right, float bottom) const {
return RoundedCorners(
top_left.Inset(left, top), top_right.Inset(right, top),
diff --git a/src/cobalt/render_tree/shadow.h b/src/cobalt/render_tree/shadow.h
index caefb8a..057c30a 100644
--- a/src/cobalt/render_tree/shadow.h
+++ b/src/cobalt/render_tree/shadow.h
@@ -32,6 +32,11 @@
const ColorRGBA& color)
: offset(offset), blur_sigma(blur_sigma), color(color) {}
+ bool operator==(const Shadow& other) const {
+ return offset == other.offset && blur_sigma == other.blur_sigma &&
+ color == other.color;
+ }
+
// Since the blur parameters represent standard deviations, most of the
// blur is contained within 3 of them, so report that as the extent of the
// blur.
diff --git a/src/cobalt/render_tree/text_node.h b/src/cobalt/render_tree/text_node.h
index 2dde330..3d35b43 100644
--- a/src/cobalt/render_tree/text_node.h
+++ b/src/cobalt/render_tree/text_node.h
@@ -46,6 +46,11 @@
const scoped_refptr<GlyphBuffer>& glyph_buffer,
const ColorRGBA& color);
+ bool operator==(const Builder& other) const {
+ return offset == other.offset && glyph_buffer == other.glyph_buffer &&
+ color == other.color && shadows == other.shadows;
+ }
+
math::Vector2dF offset;
// All of the glyph data needed to render the text.
diff --git a/src/cobalt/render_tree/viewport_filter.h b/src/cobalt/render_tree/viewport_filter.h
index 92f3d58..e4a0afa 100644
--- a/src/cobalt/render_tree/viewport_filter.h
+++ b/src/cobalt/render_tree/viewport_filter.h
@@ -33,6 +33,11 @@
const RoundedCorners& rounded_corners)
: viewport_(viewport), rounded_corners_(rounded_corners) {}
+ bool operator==(const ViewportFilter& other) const {
+ return viewport_ == other.viewport_ &&
+ rounded_corners_ == other.rounded_corners_;
+ }
+
const math::RectF& viewport() const { return viewport_; }
bool has_rounded_corners() const { return !!rounded_corners_; }
diff --git a/src/cobalt/renderer/copy_font_data.gypi b/src/cobalt/renderer/copy_font_data.gypi
index b62574e..0102e42 100644
--- a/src/cobalt/renderer/copy_font_data.gypi
+++ b/src/cobalt/renderer/copy_font_data.gypi
@@ -21,22 +21,9 @@
'source_font_files_dir': '<(static_contents_source_dir)/fonts/font_files',
'conditions': [
- [ 'cobalt_font_package == "expanded"', {
- 'source_font_config_dir': '<(static_contents_source_dir)/fonts/config/common',
-
- 'package_named_sans_serif': 4,
- 'package_named_serif': 3,
- 'package_named_fcc_fonts': 2,
- 'package_fallback_lang_non_cjk': 2,
- 'package_fallback_lang_cjk': 2,
- 'package_fallback_lang_cjk_low_quality': 0,
- 'package_fallback_lang_jp': 0,
- 'package_fallback_emoji': 1,
- 'package_fallback_symbols': 1,
- }],
-
# 'unlimited' is deprecated but is mapped to 'standard'
- [ 'cobalt_font_package == "standard" or cobalt_font_package == "unlimited"', {
+ # 'expanded' also currently maps to 'standard' but this may change in the future
+ [ 'cobalt_font_package == "standard" or cobalt_font_package == "unlimited" or cobalt_font_package == "expanded"', {
'source_font_config_dir': '<(static_contents_source_dir)/fonts/config/common',
'package_named_sans_serif': 4,
@@ -45,13 +32,12 @@
'package_fallback_lang_non_cjk': 2,
'package_fallback_lang_cjk': 1,
'package_fallback_lang_cjk_low_quality': 0,
- 'package_fallback_lang_jp': 0,
'package_fallback_emoji': 1,
'package_fallback_symbols': 1,
}],
- # '10megabytes' is deprecated but is mapped to 'limited_with_jp'
- [ 'cobalt_font_package == "limited_with_jp" or cobalt_font_package == "10megabytes"', {
+ # '10megabytes' and 'limited_with_jp' are deprecated but map to 'limited'
+ [ 'cobalt_font_package == "limited" or cobalt_font_package == "limited_with_jp" or cobalt_font_package == "10megabytes"', {
'source_font_config_dir': '<(static_contents_source_dir)/fonts/config/common',
'package_named_sans_serif': 2,
@@ -60,21 +46,6 @@
'package_fallback_lang_non_cjk': 1,
'package_fallback_lang_cjk': 0,
'package_fallback_lang_cjk_low_quality': 1,
- 'package_fallback_lang_jp': 1,
- 'package_fallback_emoji': 1,
- 'package_fallback_symbols': 1,
- }],
-
- [ 'cobalt_font_package == "limited"', {
- 'source_font_config_dir': '<(static_contents_source_dir)/fonts/config/common',
-
- 'package_named_sans_serif': 2,
- 'package_named_serif': 0,
- 'package_named_fcc_fonts': 0,
- 'package_fallback_lang_non_cjk': 1,
- 'package_fallback_lang_cjk': 0,
- 'package_fallback_lang_cjk_low_quality': 1,
- 'package_fallback_lang_jp': 0,
'package_fallback_emoji': 1,
'package_fallback_symbols': 1,
}],
@@ -88,7 +59,6 @@
'package_fallback_lang_non_cjk': 0,
'package_fallback_lang_cjk': 0,
'package_fallback_lang_cjk_low_quality': 0,
- 'package_fallback_lang_jp': 0,
'package_fallback_emoji': 0,
'package_fallback_symbols': 0,
}],
@@ -108,7 +78,6 @@
'package_fallback_lang_non_cjk': 0,
'package_fallback_lang_cjk': 0,
'package_fallback_lang_cjk_low_quality': 0,
- 'package_fallback_lang_jp': 0,
'package_fallback_emoji': 1,
'package_fallback_symbols': 0,
}],
@@ -131,9 +100,6 @@
[ 'cobalt_font_package_override_fallback_lang_cjk_low_quality >= 0', {
'package_fallback_lang_cjk_low_quality': '<(cobalt_font_package_override_fallback_lang_cjk_low_quality)',
}],
- [ 'cobalt_font_package_override_fallback_lang_jp >= 0', {
- 'package_fallback_lang_jp': '<(cobalt_font_package_override_fallback_lang_jp)',
- }],
[ 'cobalt_font_package_override_fallback_emoji >= 0', {
'package_fallback_emoji': '<(cobalt_font_package_override_fallback_emoji)',
}],
@@ -309,21 +275,11 @@
'<(source_font_files_dir)/NotoSansCJK-Regular.ttc',
],
}],
- [ 'package_fallback_lang_cjk >= 2', {
- 'files+': [
- '<(source_font_files_dir)/NotoSansCJK-Bold.ttc',
- ],
- }],
[ 'package_fallback_lang_cjk_low_quality >= 1', {
'files+': [
'<(source_font_files_dir)/DroidSansFallback.ttf',
],
}],
- [ 'package_fallback_lang_jp >= 1', {
- 'files+': [
- '<(source_font_files_dir)/NotoSansJP-Regular.otf',
- ],
- }],
[ 'package_fallback_emoji >= 1', {
'files+': [
'<(source_font_files_dir)/NotoEmoji-Regular.ttf',
diff --git a/src/cobalt/renderer/pipeline.cc b/src/cobalt/renderer/pipeline.cc
index 534f38c..187e684 100644
--- a/src/cobalt/renderer/pipeline.cc
+++ b/src/cobalt/renderer/pipeline.cc
@@ -81,13 +81,22 @@
submission_disposal_thread_("Rasterizer Submission Disposal"),
submit_even_if_render_tree_is_unchanged_(
submit_even_if_render_tree_is_unchanged),
- last_render_animations_active_(false),
+ last_did_rasterize_(false),
+ last_animations_expired_(true),
+ last_stat_tracked_animations_expired_(true),
rasterize_periodic_timer_("Renderer.Rasterize.Duration",
kRasterizePeriodicTimerEntriesPerUpdate,
false /*enable_entry_list_c_val*/),
rasterize_animations_timer_("Renderer.Rasterize.Animations",
kRasterizeAnimationsTimerMaxEntries,
true /*enable_entry_list_c_val*/),
+ rasterize_periodic_interval_timer_("Renderer.Rasterize.DurationInterval",
+ kRasterizeAnimationsTimerMaxEntries,
+ true /*enable_entry_list_c_val*/),
+ rasterize_animations_interval_timer_(
+ "Renderer.Rasterize.AnimationsInterval",
+ kRasterizeAnimationsTimerMaxEntries,
+ true /*enable_entry_list_c_val*/),
new_render_tree_rasterize_count_(
"Count.Renderer.Rasterize.NewRenderTree", 0,
"Total number of new render trees rasterized."),
@@ -152,6 +161,7 @@
// must be destroyed before we shutdown the rasterizer thread since it may
// contain references to render tree nodes and resources.
last_render_tree_ = NULL;
+ last_animated_render_tree_ = NULL;
// Submit a shutdown task to the rasterizer thread so that it can shutdown
// anything that must be shutdown from that thread.
@@ -252,12 +262,13 @@
DCHECK(rasterizer_thread_checker_.CalledOnValidThread());
TRACE_EVENT0("cobalt::renderer", "Pipeline::RasterizeCurrentTree()");
- base::TimeTicks now = base::TimeTicks::Now();
- Submission submission = submission_queue_->GetCurrentSubmission(now);
+ base::TimeTicks start_rasterize_time = base::TimeTicks::Now();
+ Submission submission =
+ submission_queue_->GetCurrentSubmission(start_rasterize_time);
bool is_new_render_tree = submission.render_tree != last_render_tree_;
bool has_render_tree_changed =
- last_render_animations_active_ || is_new_render_tree;
+ !last_animations_expired_ || is_new_render_tree;
// If our render tree hasn't changed from the one that was previously
// rendered and it's okay on this system to not flip the display buffer
@@ -271,63 +282,99 @@
render_tree::animations::AnimateNode* animate_node =
base::polymorphic_downcast<render_tree::animations::AnimateNode*>(
submission.render_tree.get());
- bool are_animations_active = animate_node->expiry() > submission.time_offset;
- // If animations are going from being inactive to active, then set the c_val
- // prior to starting the animation so that it's in the correct state while the
- // tree is being rendered.
- if (!last_render_animations_active_ && are_animations_active) {
- has_active_animations_c_val_ = true;
- }
+ // Rasterize the last submitted render tree.
+ bool did_rasterize =
+ RasterizeSubmissionToRenderTarget(submission, render_target_);
+
+ bool animations_expired = animate_node->expiry() <= submission.time_offset;
+ bool stat_tracked_animations_expired =
+ animate_node->depends_on_time_expiry() <= submission.time_offset;
+
+ UpdateRasterizeStats(did_rasterize, stat_tracked_animations_expired,
+ is_new_render_tree, start_rasterize_time,
+ base::TimeTicks::Now());
+
+ last_did_rasterize_ = did_rasterize;
+ last_animations_expired_ = animations_expired;
+ last_stat_tracked_animations_expired_ = stat_tracked_animations_expired;
+}
+
+void Pipeline::UpdateRasterizeStats(bool did_rasterize,
+ bool are_stat_tracked_animations_expired,
+ bool is_new_render_tree,
+ base::TimeTicks start_time,
+ base::TimeTicks end_time) {
+ bool last_animations_active =
+ !last_stat_tracked_animations_expired_ && last_did_rasterize_;
+ bool animations_active =
+ !are_stat_tracked_animations_expired && did_rasterize;
// The rasterization is only timed with the periodic timer when the render
// tree has changed. This ensures that the frames being timed are consistent
// between platforms that submit unchanged trees and those that don't.
- bool should_run_periodic_timer = has_render_tree_changed;
-
- // The rasterization is only timed with the animations timer when there are
- // animations to track. This applies when animations were active during either
- // the last rasterization or the current one. The reason for including the
- // last one is that if animations have just expired, then this rasterization
- // produces the final state of the animated tree.
- bool should_run_animations_timer =
- last_render_animations_active_ || are_animations_active;
-
- if (should_run_periodic_timer) {
- rasterize_periodic_timer_.Start(now);
- }
- if (should_run_animations_timer) {
- rasterize_animations_timer_.Start(now);
+ if (did_rasterize) {
+ rasterize_periodic_timer_.Start(start_time);
+ rasterize_periodic_timer_.Stop(end_time);
}
- // Rasterize the last submitted render tree.
- RasterizeSubmissionToRenderTarget(submission, render_target_);
+ if (last_animations_active || animations_active) {
+ // The rasterization is only timed with the animations timer when there are
+ // animations to track. This applies when animations were active during
+ // either the last rasterization or the current one. The reason for
+ // including the last one is that if animations have just expired, then this
+ // rasterization produces the final state of the animated tree.
+ if (did_rasterize) {
+ rasterize_animations_timer_.Start(start_time);
+ rasterize_animations_timer_.Stop(end_time);
+ }
- if (should_run_periodic_timer) {
- rasterize_periodic_timer_.Stop();
- }
- if (should_run_animations_timer) {
- rasterize_animations_timer_.Stop();
+ // If animations are going from being inactive to active, then set the c_val
+ // prior to starting the animation so that it's in the correct state while
+ // the tree is being rendered.
+ // Also, start the interval timer now. While the first entry only captures a
+ // partial interval, it's recorded to include the duration of the first
+ // submission. All subsequent entries will record a full interval.
+ if (!last_animations_active && animations_active) {
+ has_active_animations_c_val_ = true;
+ rasterize_periodic_interval_timer_.Start(start_time);
+ rasterize_animations_interval_timer_.Start(start_time);
+ }
+
+ if (!did_rasterize) {
+ // If we didn't actually rasterize anything, don't count this sample.
+ rasterize_periodic_interval_timer_.Cancel();
+ rasterize_animations_interval_timer_.Cancel();
+ } else {
+ rasterize_periodic_interval_timer_.Stop(end_time);
+ rasterize_animations_interval_timer_.Stop(end_time);
+ }
+
+ // If animations are active, then they are guaranteed at least one more
+ // interval. Start the timer to record its duration.
+ if (animations_active) {
+ rasterize_periodic_interval_timer_.Start(end_time);
+ rasterize_animations_interval_timer_.Start(end_time);
+ }
+
+ // Check for if the animations are starting or ending.
+ if (!last_animations_active && animations_active) {
+ animations_start_time_ = end_time.ToInternalValue();
+ } else if (last_animations_active && !animations_active) {
+ animations_end_time_ = end_time.ToInternalValue();
+ has_active_animations_c_val_ = false;
+ rasterize_animations_interval_timer_.Flush();
+ rasterize_animations_timer_.Flush();
+ }
}
if (is_new_render_tree) {
++new_render_tree_rasterize_count_;
- new_render_tree_rasterize_time_ = base::TimeTicks::Now().ToInternalValue();
+ new_render_tree_rasterize_time_ = end_time.ToInternalValue();
}
-
- // Check for if the animations are starting or ending.
- if (!last_render_animations_active_ && are_animations_active) {
- animations_start_time_ = base::TimeTicks::Now().ToInternalValue();
- } else if (last_render_animations_active_ && !are_animations_active) {
- animations_end_time_ = base::TimeTicks::Now().ToInternalValue();
- has_active_animations_c_val_ = false;
- rasterize_animations_timer_.Flush();
- }
-
- last_render_animations_active_ = are_animations_active;
}
-void Pipeline::RasterizeSubmissionToRenderTarget(
+bool Pipeline::RasterizeSubmissionToRenderTarget(
const Submission& submission,
const scoped_refptr<backend::RenderTarget>& render_target) {
TRACE_EVENT0("cobalt::renderer",
@@ -338,14 +385,17 @@
// |previous_animated_area_|.
if (submission.render_tree != last_render_tree_) {
last_render_tree_ = submission.render_tree;
+ last_animated_render_tree_ = NULL;
previous_animated_area_ = base::nullopt;
last_render_time_ = base::nullopt;
}
// Animate the render tree using the submitted animations.
render_tree::animations::AnimateNode* animate_node =
- base::polymorphic_downcast<render_tree::animations::AnimateNode*>(
- submission.render_tree.get());
+ last_animated_render_tree_
+ ? last_animated_render_tree_.get()
+ : base::polymorphic_downcast<render_tree::animations::AnimateNode*>(
+ submission.render_tree.get());
// Some animations require a GL graphics context to be current. Specifically,
// a call to SbPlayerGetCurrentFrame() may be made to get the current video
@@ -355,6 +405,12 @@
render_tree::animations::AnimateNode::AnimateResults results =
animate_node->Apply(submission.time_offset);
+ if (results.animated == last_animated_render_tree_ &&
+ !submit_even_if_render_tree_is_unchanged_) {
+ return false;
+ }
+ last_animated_render_tree_ = results.animated;
+
// Calculate a bounding box around the active animations. Union it with the
// bounding box around active animations from the previous frame, and we get
// a scissor rectangle marking the dirty regions of the screen.
@@ -370,13 +426,16 @@
// Rasterize the animated render tree.
rasterizer::Rasterizer::Options rasterizer_options;
rasterizer_options.dirty = redraw_area;
- rasterizer_->Submit(results.animated, render_target, rasterizer_options);
+ rasterizer_->Submit(
+ results.animated->source(), render_target, rasterizer_options);
if (!submission.on_rasterized_callback.is_null()) {
submission.on_rasterized_callback.Run();
}
last_render_time_ = submission.time_offset;
+
+ return true;
}
void Pipeline::InitializeRasterizerThread(
@@ -468,7 +527,8 @@
render_tree::animations::AnimateNode::AnimateResults results =
animate_node->Apply(submission.time_offset);
- std::string tree_dump = render_tree::DumpRenderTreeToString(results.animated);
+ std::string tree_dump =
+ render_tree::DumpRenderTreeToString(results.animated->source());
if (message.empty() || message == "undefined") {
// If no filename was specified, send output to the console.
LOG(INFO) << tree_dump.c_str();
diff --git a/src/cobalt/renderer/pipeline.h b/src/cobalt/renderer/pipeline.h
index 9df0d8a..a9abff7 100644
--- a/src/cobalt/renderer/pipeline.h
+++ b/src/cobalt/renderer/pipeline.h
@@ -109,10 +109,18 @@
// Rasterize the animated |render_tree_submission| to |render_target|,
// applying the time_offset in the submission to the animations.
- void RasterizeSubmissionToRenderTarget(
+ // Returns true only if a rasterization actually took place.
+ bool RasterizeSubmissionToRenderTarget(
const Submission& render_tree_submission,
const scoped_refptr<backend::RenderTarget>& render_target);
+ // Updates the rasterizer timer stats according to the |start_time| and
+ // |end_time| of the most recent rasterize call.
+ void UpdateRasterizeStats(bool did_rasterize,
+ bool are_stat_tracked_animations_expired,
+ bool is_new_render_tree, base::TimeTicks start_time,
+ base::TimeTicks end_time);
+
// This method is executed on the rasterizer thread and is responsible for
// constructing the rasterizer.
void InitializeRasterizerThread(
@@ -179,6 +187,10 @@
// Keeps track of the last rendered animated render tree.
scoped_refptr<render_tree::Node> last_render_tree_;
+
+ scoped_refptr<render_tree::animations::AnimateNode>
+ last_animated_render_tree_;
+
// Keeps track of the area of the screen that animations previously existed
// within, so that we can know which regions of the screens would be dirty
// next frame.
@@ -187,8 +199,14 @@
base::optional<base::TimeDelta> last_render_time_;
// Keep track of whether the last rendered tree had active animations. This
// allows us to skip rasterizing that render tree if we see it again and it
- // did not have active animations.
- bool last_render_animations_active_;
+ // did have expired animations.
+ bool last_animations_expired_;
+ // Keep track of whether the last rendered tree had animations that we're
+ // tracking stats on.
+ bool last_stat_tracked_animations_expired_;
+
+ // Did a rasterization take place in the last frame?
+ bool last_did_rasterize_;
// Timer tracking the amount of time spent in
// |RasterizeSubmissionToRenderTarget| when the render tree has changed.
@@ -199,6 +217,17 @@
// tracking is flushed when the animations expire.
base::CValCollectionTimerStats<base::CValDebug> rasterize_animations_timer_;
+ // Accumulates render tree rasterization interval times but does not flush
+ // them until the maximum number of samples is gathered.
+ base::CValCollectionTimerStats<base::CValPublic>
+ rasterize_periodic_interval_timer_;
+
+ // Timer tracking the amount of time spent in
+ // |RasterizeSubmissionToRenderTarget| while animations are active. The
+ // tracking is flushed when the animations expire.
+ base::CValCollectionTimerStats<base::CValPublic>
+ rasterize_animations_interval_timer_;
+
// The total number of new render trees that have been rasterized.
base::CVal<int> new_render_tree_rasterize_count_;
// The last time that a newly encountered render tree was first rasterized.
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.cc b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.cc
index 4ad07b9..ae68696 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.cc
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.cc
@@ -54,6 +54,10 @@
return stream_->duplicate();
}
+size_t SkTypeface_CobaltStream::GetStreamLength() const {
+ return stream_->getLength();
+}
+
SkTypeface_CobaltStreamProvider::SkTypeface_CobaltStreamProvider(
SkFileMemoryChunkStreamProvider* stream_provider, int face_index,
Style style, bool is_fixed_pitch, const SkString& family_name,
@@ -83,3 +87,11 @@
*face_index = face_index_;
return stream_provider_->OpenStream();
}
+
+size_t SkTypeface_CobaltStreamProvider::GetStreamLength() const {
+ DLOG(WARNING)
+ << "Requesting stream length of SkTypeface_CobaltStreamProvider. "
+ "This requires a file load and should be used sparingly.";
+ SkAutoTUnref<SkFileMemoryChunkStream> stream(stream_provider_->OpenStream());
+ return stream->getLength();
+}
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h
index 2ac66ab..5e30052 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h
@@ -28,10 +28,12 @@
SkTypeface_Cobalt(int face_index, Style style, bool is_fixed_pitch,
const SkString& family_name);
+ virtual size_t GetStreamLength() const = 0;
+
bool synthesizes_bold() const { return synthesizes_bold_; }
protected:
- virtual void onGetFamilyName(SkString* family_name) const SK_OVERRIDE;
+ void onGetFamilyName(SkString* family_name) const SK_OVERRIDE;
int face_index_;
SkString family_name_;
@@ -46,10 +48,12 @@
SkTypeface_CobaltStream(SkStreamAsset* stream, int face_index, Style style,
bool is_fixed_pitch, const SkString& family_name);
- virtual void onGetFontDescriptor(SkFontDescriptor* descriptor,
- bool* serialize) const SK_OVERRIDE;
+ void onGetFontDescriptor(SkFontDescriptor* descriptor,
+ bool* serialize) const SK_OVERRIDE;
- virtual SkStreamAsset* onOpenStream(int* face_index) const SK_OVERRIDE;
+ SkStreamAsset* onOpenStream(int* face_index) const SK_OVERRIDE;
+
+ size_t GetStreamLength() const SK_OVERRIDE;
private:
typedef SkTypeface_Cobalt INHERITED;
@@ -64,10 +68,12 @@
Style style, bool is_fixed_pitch, const SkString& family_name,
bool disable_synthetic_bolding);
- virtual void onGetFontDescriptor(SkFontDescriptor* descriptor,
- bool* serialize) const SK_OVERRIDE;
+ void onGetFontDescriptor(SkFontDescriptor* descriptor,
+ bool* serialize) const SK_OVERRIDE;
- virtual SkStreamAsset* onOpenStream(int* face_index) const SK_OVERRIDE;
+ SkStreamAsset* onOpenStream(int* face_index) const SK_OVERRIDE;
+
+ size_t GetStreamLength() const SK_OVERRIDE;
private:
typedef SkTypeface_Cobalt INHERITED;
diff --git a/src/cobalt/renderer/rasterizer/skia/typeface.cc b/src/cobalt/renderer/rasterizer/skia/typeface.cc
index e4396fe..6e0866d 100644
--- a/src/cobalt/renderer/rasterizer/skia/typeface.cc
+++ b/src/cobalt/renderer/rasterizer/skia/typeface.cc
@@ -18,12 +18,6 @@
#include "third_party/skia/include/core/SkPaint.h"
-namespace {
-
-const uint32 kEstimatedBytesPerGlyph = 256;
-
-} // namespace
-
namespace cobalt {
namespace renderer {
namespace rasterizer {
@@ -43,7 +37,7 @@
}
uint32 SkiaTypeface::GetEstimatedSizeInBytes() const {
- return typeface_->countGlyphs() * kEstimatedBytesPerGlyph;
+ return static_cast<uint32>(typeface_->GetStreamLength());
}
scoped_refptr<render_tree::Font> SkiaTypeface::CreateFontWithSize(
diff --git a/src/cobalt/renderer/submission_queue.cc b/src/cobalt/renderer/submission_queue.cc
index 20a1e39..b7b861e 100644
--- a/src/cobalt/renderer/submission_queue.cc
+++ b/src/cobalt/renderer/submission_queue.cc
@@ -89,8 +89,11 @@
base::polymorphic_downcast<render_tree::animations::AnimateNode*>(
submission_queue_.front().render_tree.get());
- if (animate_node->expiry() <= submission_time(now) &&
- animate_node->expiry() <=
+ // Check the expiration of only animations that depend on the time
+ // parameter, since they are the only ones that will be affected by snapping
+ // time.
+ if (animate_node->depends_on_time_expiry() <= submission_time(now) &&
+ animate_node->depends_on_time_expiry() <=
latest_to_submission_time + render_time(now)) {
to_submission_time_in_ms_.SnapToTarget();
}
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.cc b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.cc
index 8951eaf..0f32130 100644
--- a/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.cc
+++ b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.cc
@@ -108,7 +108,11 @@
packet.data = const_cast<uint8_t*>(input_buffer.data());
packet.size = input_buffer.size();
+#if LIBAVUTIL_VERSION_MAJOR > 52
+ av_frame_unref(av_frame_);
+#else // LIBAVUTIL_VERSION_MAJOR > 52
avcodec_get_frame_defaults(av_frame_);
+#endif // LIBAVUTIL_VERSION_MAJOR > 52
int frame_decoded = 0;
int result =
avcodec_decode_audio4(codec_context_, av_frame_, &frame_decoded, &packet);
@@ -219,7 +223,11 @@
return;
}
+#if LIBAVUTIL_VERSION_MAJOR > 52
+ av_frame_ = av_frame_alloc();
+#else // LIBAVUTIL_VERSION_MAJOR > 52
av_frame_ = avcodec_alloc_frame();
+#endif // LIBAVUTIL_VERSION_MAJOR > 52
if (av_frame_ == NULL) {
SB_LOG(ERROR) << "Unable to allocate audio frame";
TeardownCodec();
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_common.h b/src/starboard/shared/ffmpeg/ffmpeg_common.h
index 4203e91..9c63c1d 100644
--- a/src/starboard/shared/ffmpeg/ffmpeg_common.h
+++ b/src/starboard/shared/ffmpeg/ffmpeg_common.h
@@ -27,6 +27,16 @@
#include "starboard/shared/internal_only.h"
+#if !defined(LIBAVUTIL_VERSION_MAJOR)
+#error "LIBAVUTIL_VERSION_MAJOR not defined"
+#endif // !defined(LIBAVUTIL_VERSION_MAJOR)
+
+#if LIBAVUTIL_VERSION_MAJOR > 52
+#define PIX_FMT_NONE AV_PIX_FMT_NONE
+#define PIX_FMT_YUV420P AV_PIX_FMT_YUV420P
+#define PIX_FMT_YUVJ420P AV_PIX_FMT_YUVJ420P
+#endif // LIBAVUTIL_VERSION_MAJOR > 52
+
namespace starboard {
namespace shared {
namespace ffmpeg {
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc
index 2d4e659..48b5774 100644
--- a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc
+++ b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc
@@ -37,6 +37,58 @@
return width * height * 3 / 2;
}
+#if LIBAVUTIL_VERSION_MAJOR > 52
+
+void ReleaseBuffer(void* opaque, uint8_t* data) {
+ SbMemorySet(data, 0, sizeof(data));
+ SbMemoryDeallocate(data);
+}
+
+int AllocateBuffer(AVCodecContext* codec_context, AVFrame* frame, int flags) {
+ if (codec_context->pix_fmt != PIX_FMT_YUV420P &&
+ codec_context->pix_fmt != PIX_FMT_YUVJ420P) {
+ SB_DLOG(WARNING) << "Unsupported pix_fmt " << codec_context->pix_fmt;
+ return AVERROR(EINVAL);
+ }
+
+ int ret =
+ av_image_check_size(codec_context->width, codec_context->height, 0, NULL);
+ if (ret < 0) {
+ return ret;
+ }
+
+ // Align to kAlignment * 2 as we will divide y_stride by 2 for u and v planes
+ size_t y_stride = AlignUp(codec_context->width, kAlignment * 2);
+ size_t uv_stride = y_stride / 2;
+ size_t aligned_height = AlignUp(codec_context->height, kAlignment * 2);
+
+ uint8_t* frame_buffer = reinterpret_cast<uint8_t*>(SbMemoryAllocateAligned(
+ kAlignment, GetYV12SizeInBytes(y_stride, aligned_height)));
+
+ frame->data[0] = frame_buffer;
+ frame->linesize[0] = y_stride;
+
+ frame->data[1] = frame_buffer + y_stride * aligned_height;
+ frame->linesize[1] = uv_stride;
+
+ frame->data[2] = frame->data[1] + uv_stride * aligned_height / 2;
+ frame->linesize[2] = uv_stride;
+
+ frame->opaque = frame;
+ frame->width = codec_context->width;
+ frame->height = codec_context->height;
+ frame->format = codec_context->pix_fmt;
+
+ frame->reordered_opaque = codec_context->reordered_opaque;
+
+ frame->buf[0] = av_buffer_create(frame_buffer,
+ GetYV12SizeInBytes(y_stride, aligned_height),
+ &ReleaseBuffer, frame->opaque, 0);
+ return 0;
+}
+
+#else // LIBAVUTIL_VERSION_MAJOR > 52
+
int AllocateBuffer(AVCodecContext* codec_context, AVFrame* frame) {
if (codec_context->pix_fmt != PIX_FMT_YUV420P &&
codec_context->pix_fmt != PIX_FMT_YUVJ420P) {
@@ -91,6 +143,7 @@
SbMemorySet(frame->data, 0, sizeof(frame->data));
}
+#endif // LIBAVUTIL_VERSION_MAJOR > 52
} // namespace
VideoDecoder::VideoDecoder(SbMediaVideoCodec video_codec)
@@ -205,7 +258,11 @@
bool VideoDecoder::DecodePacket(AVPacket* packet) {
SB_DCHECK(packet != NULL);
+#if LIBAVUTIL_VERSION_MAJOR > 52
+ av_frame_unref(av_frame_);
+#else // LIBAVUTIL_VERSION_MAJOR > 52
avcodec_get_frame_defaults(av_frame_);
+#endif // LIBAVUTIL_VERSION_MAJOR > 52
int frame_decoded = 0;
int result =
avcodec_decode_video2(codec_context_, av_frame_, &frame_decoded, packet);
@@ -251,8 +308,12 @@
codec_context_->thread_count = 2;
codec_context_->opaque = this;
codec_context_->flags |= CODEC_FLAG_EMU_EDGE;
+#if LIBAVUTIL_VERSION_MAJOR > 52
+ codec_context_->get_buffer2 = AllocateBuffer;
+#else // LIBAVUTIL_VERSION_MAJOR > 52
codec_context_->get_buffer = AllocateBuffer;
codec_context_->release_buffer = ReleaseBuffer;
+#endif // LIBAVUTIL_VERSION_MAJOR > 52
codec_context_->extradata = NULL;
codec_context_->extradata_size = 0;
@@ -272,7 +333,11 @@
return;
}
+#if LIBAVUTIL_VERSION_MAJOR > 52
+ av_frame_ = av_frame_alloc();
+#else // LIBAVUTIL_VERSION_MAJOR > 52
av_frame_ = avcodec_alloc_frame();
+#endif // LIBAVUTIL_VERSION_MAJOR > 52
if (av_frame_ == NULL) {
SB_LOG(ERROR) << "Unable to allocate audio frame";
TeardownCodec();
diff --git a/src/starboard/tools/raspi/run_test.py b/src/starboard/tools/raspi/run_test.py
index 5119c3a..326b654 100755
--- a/src/starboard/tools/raspi/run_test.py
+++ b/src/starboard/tools/raspi/run_test.py
@@ -21,9 +21,11 @@
import functools
import logging
import os
+import re
import signal
import sys
import textwrap
+import time
import pexpect
@@ -32,6 +34,22 @@
_RASPI_USERNAME = 'pi'
_RASPI_PASSWORD = 'raspberry'
+# Timeouts are in seconds
+_PEXPECT_DEFAULT_TIMEOUT = 600
+_PEXPECT_EXPECT_TIMEOUT = 60
+
+
+def _CleanupProcess(process):
+ """Closes current pexpect process.
+
+ Args:
+ process: Current pexpect process.
+ """
+ if process is not None and process.isalive():
+ # Send ctrl-c to the raspi.
+ process.sendline(chr(3))
+ process.close()
+
# pylint: disable=unused-argument
def _SigIntOrSigTermHandler(process, signum, frame):
@@ -44,14 +62,11 @@
frame: Current stack frame. Passed in when the signal handler is called by
python runtime.
"""
- if process.isalive():
- # Send ctrl-c to the raspi.
- process.sendline(chr(3))
- process.close()
+ _CleanupProcess(process)
sys.exit(signum)
-def RunTest(test_path, raspi_ip, flags):
+def _RunTest(test_path, raspi_ip, flags):
"""Run a test on a Raspi machine and print relevant stdout.
Args:
@@ -61,70 +76,103 @@
Returns:
Exit status of running the test.
-
- Raises:
- ValueError: Raised if test_path is invalid.
"""
- if not os.path.isfile(test_path):
- raise ValueError('test_path ({}) must be a file.'.format(test_path))
+ return_value = 1
- sys.stdout.write('Process launched, ID={}\n'.format(os.getpid()))
- sys.stdout.flush()
+ try:
+ process = None
- test_dir_path, test_file = os.path.split(test_path)
- test_base_dir = os.path.basename(os.path.normpath(test_dir_path))
+ if not os.path.isfile(test_path):
+ raise ValueError('test_path ({}) must be a file.'.format(test_path))
- raspi_user_hostname = _RASPI_USERNAME + '@' + raspi_ip
- raspi_test_path = os.path.join(test_base_dir, test_file)
+ # This is used to strip ansi color codes from output.
+ sanitize_line_re = re.compile(r'\x1b[^m]*m')
- # rsync the test files to the raspi
- options = '-avzh --exclude obj*'
- source = test_dir_path
- destination = raspi_user_hostname + ':~/'
- command = 'rsync ' + options + ' ' + source + ' ' + destination
- process = pexpect.spawn(command, timeout=120)
+ sys.stdout.write('Process launched, ID={}\n'.format(os.getpid()))
+ sys.stdout.flush()
- signal.signal(signal.SIGINT,
- functools.partial(_SigIntOrSigTermHandler, process))
- signal.signal(signal.SIGTERM,
- functools.partial(_SigIntOrSigTermHandler, process))
+ test_dir_path, test_file = os.path.split(test_path)
+ test_base_dir = os.path.basename(os.path.normpath(test_dir_path))
- process.expect(r'\S+ password:')
- process.sendline(_RASPI_PASSWORD)
+ raspi_user_hostname = _RASPI_USERNAME + '@' + raspi_ip
+ raspi_test_path = os.path.join(test_base_dir, test_file)
- while True:
- line = process.readline()
- if line:
+ # rsync the test files to the raspi
+ options = '-avzh --exclude obj*'
+ source = test_dir_path
+ destination = raspi_user_hostname + ':~/'
+ rsync_command = 'rsync ' + options + ' ' + source + ' ' + destination
+ process = pexpect.spawn(rsync_command, timeout=_PEXPECT_DEFAULT_TIMEOUT)
+
+ signal.signal(signal.SIGINT,
+ functools.partial(_SigIntOrSigTermHandler, process))
+ signal.signal(signal.SIGTERM,
+ functools.partial(_SigIntOrSigTermHandler, process))
+
+ process.expect(r'\S+ password:', timeout=_PEXPECT_EXPECT_TIMEOUT)
+ process.sendline(_RASPI_PASSWORD)
+
+ while True:
+ line = sanitize_line_re.sub('', process.readline())
+ if line:
+ sys.stdout.write(line)
+ sys.stdout.flush()
+ else:
+ break
+
+ # ssh into the raspi and run the test
+ ssh_command = 'ssh ' + raspi_user_hostname
+ process = pexpect.spawn(ssh_command, timeout=_PEXPECT_DEFAULT_TIMEOUT)
+
+ signal.signal(signal.SIGINT,
+ functools.partial(_SigIntOrSigTermHandler, process))
+ signal.signal(signal.SIGTERM,
+ functools.partial(_SigIntOrSigTermHandler, process))
+
+ process.expect(r'\S+ password:', timeout=_PEXPECT_EXPECT_TIMEOUT)
+ process.sendline(_RASPI_PASSWORD)
+
+ # Escape command line metacharacters in the flags
+ meta_chars = '()[]{}%!^"<>&|'
+ meta_re = re.compile('(' + '|'.join(
+ re.escape(char) for char in list(meta_chars)) + ')')
+ escaped_flags = re.subn(meta_re, r'\\\1', flags)[0]
+
+ test_command = raspi_test_path + ' ' + escaped_flags
+ test_time_tag = 'TEST-{time}'.format(time=time.time())
+ test_success_tag = 'succeeded'
+ test_failure_tag = 'failed'
+ test_success_output = ' && echo ' + test_time_tag + ' ' + test_success_tag
+ test_failure_output = ' || echo ' + test_time_tag + ' ' + test_failure_tag
+ process.sendline(test_command + test_success_output + test_failure_output)
+
+ while True:
+ line = sanitize_line_re.sub('', process.readline())
+ if not line:
+ break
sys.stdout.write(line)
sys.stdout.flush()
- else:
- break
+ if line.startswith(test_time_tag):
+ if line.find(test_success_tag) != -1:
+ return_value = 0
+ break
- # ssh into the raspi and run the test
- command = 'ssh ' + raspi_user_hostname
- process = pexpect.spawn(command, timeout=120)
+ except ValueError:
+ logging.exception('Test path invalid.')
+ except pexpect.EOF:
+ logging.exception('pexpect encountered EOF while reading line.')
+ except pexpect.TIMEOUT:
+ logging.exception('pexpect timed out while reading line.')
+ # pylint: disable=W0703
+ except Exception:
+ logging.exception('Error occured while running test.')
+ finally:
+ _CleanupProcess(process)
- signal.signal(signal.SIGINT,
- functools.partial(_SigIntOrSigTermHandler, process))
- signal.signal(signal.SIGTERM,
- functools.partial(_SigIntOrSigTermHandler, process))
-
- process.expect(r'\S+ password:')
- process.sendline(_RASPI_PASSWORD)
- process.sendline(raspi_test_path + ' ' + flags)
-
- while True:
- line = process.readline()
- if line:
- sys.stdout.write(line)
- sys.stdout.flush()
- else:
- break
-
- return 0
+ return return_value
-def AddTargetFlag(parser):
+def _AddTargetFlag(parser):
"""Add target to argument parser."""
parser.add_argument(
'-t',
@@ -138,7 +186,7 @@
nargs='?')
-def AddFlagsFlag(parser, default=None):
+def _AddFlagsFlag(parser, default=None):
"""Add flags to argument parser.
Args:
@@ -173,21 +221,13 @@
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description=textwrap.dedent(__doc__))
- AddFlagsFlag(parser)
- AddTargetFlag(parser)
+ _AddFlagsFlag(parser)
+ _AddTargetFlag(parser)
parser.add_argument('test_path', help='Path of test to be run.', type=str)
args = parser.parse_args()
- try:
- return_value = RunTest(
- args.test_path, raspi_ip=args.target, flags=args.flags)
- # pylint: disable=W0703
- except Exception:
- logging.exception('Error occured while running binary.')
- return_value = 1
-
- return return_value
+ return _RunTest(args.test_path, raspi_ip=args.target, flags=args.flags)
if __name__ == '__main__':
diff --git a/src/third_party/libwebp/dec/idec.c b/src/third_party/libwebp/dec/idec.c
index 5bf79d3..105a3dd 100644
--- a/src/third_party/libwebp/dec/idec.c
+++ b/src/third_party/libwebp/dec/idec.c
@@ -358,30 +358,33 @@
}
// Partition #0
-static int CopyParts0Data(WebPIDecoder* const idec) {
+static VP8StatusCode CopyParts0Data(WebPIDecoder* const idec) {
VP8Decoder* const dec = (VP8Decoder*)idec->dec_;
VP8BitReader* const br = &dec->br_;
- const size_t psize = br->buf_end_ - br->buf_;
+ const size_t part_size = br->buf_end_ - br->buf_;
MemBuffer* const mem = &idec->mem_;
assert(!idec->is_lossless_);
assert(mem->part0_buf_ == NULL);
- assert(psize > 0);
- assert(psize <= mem->part0_size_); // Format limit: no need for runtime check
+ // the following is a format limitation, no need for runtime check:
+ assert(part_size <= mem->part0_size_);
+ if (part_size == 0) { // can't have zero-size partition #0
+ return VP8_STATUS_BITSTREAM_ERROR;
+ }
if (mem->mode_ == MEM_MODE_APPEND) {
// We copy and grab ownership of the partition #0 data.
- uint8_t* const part0_buf = (uint8_t*)malloc(psize);
+ uint8_t* const part0_buf = (uint8_t*)malloc(part_size);
if (part0_buf == NULL) {
- return 0;
+ return VP8_STATUS_OUT_OF_MEMORY;
}
- memcpy(part0_buf, br->buf_, psize);
+ memcpy(part0_buf, br->buf_, part_size);
mem->part0_buf_ = part0_buf;
br->buf_ = part0_buf;
- br->buf_end_ = part0_buf + psize;
+ br->buf_end_ = part0_buf + part_size;
} else {
// Else: just keep pointers to the partition #0's data in dec_->br_.
}
- mem->start_ += psize;
- return 1;
+ mem->start_ += part_size;
+ return VP8_STATUS_OK;
}
static VP8StatusCode DecodePartition0(WebPIDecoder* const idec) {
@@ -412,8 +415,9 @@
return IDecError(idec, dec->status_);
}
- if (!CopyParts0Data(idec)) {
- return IDecError(idec, VP8_STATUS_OUT_OF_MEMORY);
+ dec->status_ = CopyParts0Data(idec);
+ if (dec->status_ != VP8_STATUS_OK) {
+ return IDecError(idec, dec->status_);
}
// Finish setting up the decoding parameters. Will call io->setup().
