Import Cobalt 9.89162
diff --git a/src/cobalt/browser/stack_size_constants.h b/src/cobalt/browser/stack_size_constants.h
index d6b33fc..3d7d7d2 100644
--- a/src/cobalt/browser/stack_size_constants.h
+++ b/src/cobalt/browser/stack_size_constants.h
@@ -21,12 +21,12 @@
namespace browser {
#if defined(COBALT_BUILD_TYPE_DEBUG)
// Non-optimized builds require a bigger stack size.
- const size_t kBaseStackSize = 2 * 1024 * 1024;
+ const size_t kBaseStackSize = 3 * 1024 * 1024;
#elif defined(COBALT_BUILD_TYPE_DEVEL)
// Devel builds require a slightly bigger stack size.
- const size_t kBaseStackSize = 448 * 1024;
+ const size_t kBaseStackSize = 832 * 1024;
#else
- const size_t kBaseStackSize = 384 * 1024;
+ const size_t kBaseStackSize = 768 * 1024;
#endif
const size_t kWebModuleStackSize =
kBaseStackSize + base::kAsanAdditionalStackSize;
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index 7b38425..1bb91e9 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-76656
\ No newline at end of file
+89162
\ No newline at end of file
diff --git a/src/cobalt/css_parser/grammar.y b/src/cobalt/css_parser/grammar.y
index 86a9ca0..063c59c 100644
--- a/src/cobalt/css_parser/grammar.y
+++ b/src/cobalt/css_parser/grammar.y
@@ -6257,7 +6257,6 @@
std::string property_name = $1.ToString();
DCHECK_GT(property_name.size(), 0U);
-#ifdef __LB_SHELL__FORCE_LOGGING__
// Do not warn about non-standard or non-WebKit properties.
if (property_name[0] != '-') {
base::AutoLock lock(non_trivial_static_fields.Get().lock);
@@ -6270,7 +6269,6 @@
parser_impl->LogWarning(@1, "unsupported property " + property_name);
}
}
-#endif // __LB_SHELL__FORCE_LOGGING__
$$ = NULL;
}
diff --git a/src/cobalt/css_parser/parser.cc b/src/cobalt/css_parser/parser.cc
index 7be1525..086782c 100644
--- a/src/cobalt/css_parser/parser.cc
+++ b/src/cobalt/css_parser/parser.cc
@@ -229,7 +229,6 @@
};
// TODO: Stop deduplicating warnings.
-#ifdef __LB_SHELL__FORCE_LOGGING__
namespace {
struct NonTrivialStaticFields {
@@ -242,7 +241,6 @@
LAZY_INSTANCE_INITIALIZER;
} // namespace
-#endif // __LB_SHELL__FORCE_LOGGING__
ParserImpl::ParserImpl(const std::string& input,
const base::SourceLocation& input_location,
diff --git a/src/cobalt/debug/debug_web_server.cc b/src/cobalt/debug/debug_web_server.cc
index 76b371f..6ffd152 100644
--- a/src/cobalt/debug/debug_web_server.cc
+++ b/src/cobalt/debug/debug_web_server.cc
@@ -80,21 +80,11 @@
return base::nullopt;
}
-std::string GetLocalIpAddress() {
+base::optional<std::string> GetLocalIpAddress() {
net::IPEndPoint ip_addr;
-#if defined(__LB_SHELL__)
- struct sockaddr_in addr = {0};
- addr.sin_family = AF_INET;
- lb_get_local_ip_address(&addr.sin_addr);
- bool result =
- ip_addr.FromSockAddr(reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
- DCHECK(result);
-#elif defined(OS_STARBOARD)
-
-#if SB_API_VERSION >= 4
SbSocketAddress local_ip;
- SbMemorySet(&(local_ip.address), 0, sizeof(local_ip.address));
-
+ SbMemorySet(&local_ip, 0, sizeof(local_ip));
+#if SB_API_VERSION >= 4
bool result = false;
// Prefer IPv4 addresses, as they're easier to type for debugging.
@@ -115,17 +105,24 @@
}
}
- DCHECK(result);
+ if (!result) {
+ DLOG(WARNING) << "Unable to get a local interface address.";
+ return base::nullopt;
+ }
#else
- SbSocketAddress sb_address;
- bool result = SbSocketGetLocalInterfaceAddress(&sb_address);
- DCHECK(result);
- result = ip_addr.FromSbSocketAddress(&sb_address);
+ bool result = SbSocketGetLocalInterfaceAddress(&local_ip);
+ if (!result) {
+ DLOG(WARNING) << "Unable to get a local interface address.";
+ return base::nullopt;
+ }
+
+ result = ip_addr.FromSbSocketAddress(&local_ip);
+ if (!result) {
+ LOG(WARNING) << "Got invalid local interface address.";
+ return base::nullopt;
+ }
#endif // SB_API_VERSION >= 4
-#else
-#error "Not Implemented."
-#endif
return ip_addr.ToStringWithoutPort();
}
@@ -339,8 +336,13 @@
DCHECK(thread_checker_.CalledOnValidThread());
// Create http server
- const std::string ip_addr = GetLocalIpAddress();
- factory_.reset(new net::TCPListenSocketFactory(ip_addr, port));
+ const base::optional<std::string> ip_addr = GetLocalIpAddress();
+ if (!ip_addr) {
+ DLOG(WARNING)
+ << "Could not get a local IP address for the debug web server.";
+ return;
+ }
+ factory_.reset(new net::TCPListenSocketFactory(*ip_addr, port));
server_ = new net::HttpServer(*factory_, this);
std::string address;
diff --git a/src/cobalt/loader/image/animated_webp_image.cc b/src/cobalt/loader/image/animated_webp_image.cc
index eef28b9..123d945 100644
--- a/src/cobalt/loader/image/animated_webp_image.cc
+++ b/src/cobalt/loader/image/animated_webp_image.cc
@@ -51,7 +51,6 @@
frame_count_(0),
loop_count_(kLoopInfinite),
current_frame_index_(0),
- next_frame_index_(0),
should_dispose_previous_frame_to_background_(false),
resource_provider_(resource_provider),
frame_provider_(new FrameProvider()) {
@@ -59,7 +58,7 @@
"AnimatedWebPImage::AnimatedWebPImage()");
}
-scoped_refptr<const AnimatedImage::FrameProvider>
+scoped_refptr<AnimatedImage::FrameProvider>
AnimatedWebPImage::GetFrameProvider() {
TRACE_EVENT0("cobalt::loader::image",
"AnimatedWebPImage::GetFrameProvider()");
@@ -178,25 +177,25 @@
base::Bind(&AnimatedWebPImage::DecodeFrames, base::Unretained(this)));
}
- UpdateTimelineInfo();
-
- // Decode the frames from current frame to next frame and blend the results.
- for (int frame_index = current_frame_index_ + 1;
- frame_index <= next_frame_index_; ++frame_index) {
- if (!DecodeOneFrame(frame_index)) {
- break;
- }
+ if (AdvanceFrame()) {
+ // Decode the frames from current frame to next frame and blend the results.
+ DecodeOneFrame(current_frame_index_);
}
- current_frame_index_ = next_frame_index_;
// Set up the next time to call the decode callback.
if (is_playing_) {
- base::TimeDelta delay = next_frame_time_ - base::TimeTicks::Now();
const base::TimeDelta min_delay =
base::TimeDelta::FromMilliseconds(kMinimumDelayInMilliseconds);
- if (delay < min_delay) {
+ base::TimeDelta delay;
+ if (next_frame_time_) {
+ delay = *next_frame_time_ - base::TimeTicks::Now();
+ if (delay < min_delay) {
+ delay = min_delay;
+ }
+ } else {
delay = min_delay;
}
+
message_loop_->PostDelayedTask(FROM_HERE, decode_closure_.callback(),
delay);
}
@@ -294,44 +293,78 @@
return true;
}
-void AnimatedWebPImage::UpdateTimelineInfo() {
- TRACE_EVENT0("cobalt::loader::image",
- "AnimatedWebPImage::UpdateTimelineInfo()");
+bool AnimatedWebPImage::AdvanceFrame() {
+ TRACE_EVENT0("cobalt::loader::image", "AnimatedWebPImage::AdvanceFrame()");
TRACK_MEMORY_SCOPE("Rendering");
DCHECK(message_loop_->BelongsToCurrentThread());
lock_.AssertAcquired();
base::TimeTicks current_time = base::TimeTicks::Now();
- next_frame_index_ = current_frame_index_ ? current_frame_index_ : 1;
- while (true) {
- // Decode frames, until a frame such that the duration covers the current
- // time, i.e. the next frame should be displayed in the future.
- WebPIterator webp_iterator;
- WebPDemuxGetFrame(demux_, next_frame_index_, &webp_iterator);
- next_frame_time_ = current_frame_time_ + base::TimeDelta::FromMilliseconds(
- webp_iterator.duration);
- WebPDemuxReleaseIterator(&webp_iterator);
- if (current_time < next_frame_time_) {
- break;
+
+ // If the WebP image hasn't been fully fetched, then stop on the current
+ // frame.
+ if (demux_state_ == WEBP_DEMUX_PARSED_HEADER) {
+ return false;
+ }
+
+ // If we're done playing the animation, do nothing.
+ if (LoopingFinished()) {
+ return false;
+ }
+
+ // If it's still not time to advance to the next frame, do nothing.
+ if (next_frame_time_ && current_time < *next_frame_time_) {
+ return false;
+ }
+
+ // Always wait for a consumer to consume the previous frame before moving
+ // forward with decoding the next frame.
+ if (!frame_provider_->FrameConsumed()) {
+ return false;
+ }
+
+ if (next_frame_time_) {
+ current_frame_time_ = *next_frame_time_;
+ } else {
+ current_frame_time_ = current_time;
+ }
+
+ ++current_frame_index_;
+ if (current_frame_index_ == frame_count_) {
+ // Check if we have finished looping, and if so return indicating that there
+ // is no additional frame available.
+ if (LoopingFinished()) {
+ next_frame_time_ = base::nullopt;
+ return false;
}
- current_frame_time_ = next_frame_time_;
- if (next_frame_index_ < frame_count_) {
- next_frame_index_++;
- } else {
- DCHECK_EQ(next_frame_index_, frame_count_);
- // If the WebP image hasn't been fully fetched, or we've reached the end
- // of the last loop, then stop on the current frame.
- if (demux_state_ == WEBP_DEMUX_PARSED_HEADER || loop_count_ == 1) {
- break;
- }
- next_frame_index_ = 1;
- current_frame_index_ = 0;
- if (loop_count_ != kLoopInfinite) {
- loop_count_--;
- }
+ // Loop around to the beginning
+ current_frame_index_ = 0;
+ if (loop_count_ != kLoopInfinite) {
+ loop_count_--;
}
}
+
+ // Update the time in the future at which point we should switch to the
+ // frame after the new current frame.
+ next_frame_time_ =
+ current_frame_time_ + GetFrameDuration(current_frame_index_);
+ if (next_frame_time_ < current_time) {
+ // Don't let the animation fall back for more than a frame.
+ next_frame_time_ = current_time;
+ }
+
+ return true;
+}
+
+base::TimeDelta AnimatedWebPImage::GetFrameDuration(int frame_index) {
+ lock_.AssertAcquired();
+ WebPIterator webp_iterator;
+ WebPDemuxGetFrame(demux_, frame_index, &webp_iterator);
+ base::TimeDelta frame_duration =
+ base::TimeDelta::FromMilliseconds(webp_iterator.duration);
+ WebPDemuxReleaseIterator(&webp_iterator);
+ return frame_duration;
}
scoped_ptr<render_tree::ImageData> AnimatedWebPImage::AllocateImageData(
@@ -346,6 +379,10 @@
return image_data.Pass();
}
+bool AnimatedWebPImage::LoopingFinished() const {
+ return loop_count_ == 1 && current_frame_index_ == frame_count_;
+}
+
} // namespace image
} // namespace loader
} // namespace cobalt
diff --git a/src/cobalt/loader/image/animated_webp_image.h b/src/cobalt/loader/image/animated_webp_image.h
index 179d42e..8714c46 100644
--- a/src/cobalt/loader/image/animated_webp_image.h
+++ b/src/cobalt/loader/image/animated_webp_image.h
@@ -45,18 +45,21 @@
const math::Size& GetSize() const OVERRIDE { return size_; }
uint32 GetEstimatedSizeInBytes() const OVERRIDE {
- return static_cast<uint32>(data_buffer_.size());
+ // Return the size of 2 frames of images, since we can have two frames in
+ // memory at a time (the previous decode image passed to the frame provider
+ // and the next frame that is composed from the previous frame).
+ return size_.GetArea() * 4 * 2 + static_cast<uint32>(data_buffer_.size());
}
bool IsOpaque() const OVERRIDE { return is_opaque_; }
- scoped_refptr<const FrameProvider> GetFrameProvider() OVERRIDE;
+ scoped_refptr<FrameProvider> GetFrameProvider() OVERRIDE;
void Play(const scoped_refptr<base::MessageLoopProxy>& message_loop) OVERRIDE;
void Stop() OVERRIDE;
- void AppendChunk(const uint8* data, size_t size);
+ void AppendChunk(const uint8* data, size_t input_byte);
private:
~AnimatedWebPImage() OVERRIDE;
@@ -72,11 +75,17 @@
// Decodes the frame with the given index, returns if it succeeded.
bool DecodeOneFrame(int frame_index);
- // Updates the index and time info of the current and next frames.
- void UpdateTimelineInfo();
-
scoped_ptr<render_tree::ImageData> AllocateImageData(const math::Size& size);
+ // If the time is right, updates the index and time info of the current frame.
+ bool AdvanceFrame();
+
+ // Returns the duration of the given frame index.
+ base::TimeDelta GetFrameDuration(int frame_index);
+
+ // Returns true if the animation loop is finished.
+ bool LoopingFinished() const;
+
const math::Size size_;
const bool is_opaque_;
const render_tree::PixelFormat pixel_format_;
@@ -89,7 +98,6 @@
// looping infinitely.
int loop_count_;
int current_frame_index_;
- int next_frame_index_;
bool should_dispose_previous_frame_to_background_;
render_tree::ResourceProvider* resource_provider_;
scoped_refptr<base::MessageLoopProxy> message_loop_;
@@ -98,7 +106,7 @@
math::RectF previous_frame_rect_;
base::CancelableClosure decode_closure_;
base::TimeTicks current_frame_time_;
- base::TimeTicks next_frame_time_;
+ base::optional<base::TimeTicks> next_frame_time_;
// The original encoded data.
std::vector<uint8> data_buffer_;
scoped_refptr<render_tree::Image> current_canvas_;
diff --git a/src/cobalt/loader/image/image.h b/src/cobalt/loader/image/image.h
index fe77dac..2b72010 100644
--- a/src/cobalt/loader/image/image.h
+++ b/src/cobalt/loader/image/image.h
@@ -88,13 +88,22 @@
// that was in there.
class FrameProvider : public base::RefCountedThreadSafe<FrameProvider> {
public:
+ FrameProvider() : frame_consumed_(true) {}
+
void SetFrame(const scoped_refptr<render_tree::Image>& frame) {
base::AutoLock lock(mutex_);
frame_ = frame;
+ frame_consumed_ = false;
}
- scoped_refptr<render_tree::Image> GetFrame() const {
+ bool FrameConsumed() const {
base::AutoLock lock(mutex_);
+ return frame_consumed_;
+ }
+
+ scoped_refptr<render_tree::Image> GetFrame() {
+ base::AutoLock lock(mutex_);
+ frame_consumed_ = true;
return frame_;
}
@@ -103,6 +112,9 @@
friend class base::RefCountedThreadSafe<FrameProvider>;
mutable base::Lock mutex_;
+ // True if a call to FrameConsumed() has been made after the last call to
+ // SetFrame().
+ bool frame_consumed_;
scoped_refptr<render_tree::Image> frame_;
};
@@ -121,11 +133,11 @@
// Returns a FrameProvider object from which frames can be pulled out of.
// The AnimatedImage object is expected to push frames into the FrameProvider
// as it generates them.
- virtual scoped_refptr<const FrameProvider> GetFrameProvider() = 0;
+ virtual scoped_refptr<FrameProvider> GetFrameProvider() = 0;
// This callback is intended to be used in a render_tree::AnimateNode.
static void AnimateCallback(
- scoped_refptr<const FrameProvider> frame_provider,
+ scoped_refptr<FrameProvider> frame_provider,
const math::RectF& destination_rect,
const math::Matrix3F& local_transform,
render_tree::ImageNode::Builder* image_node_builder,
diff --git a/src/cobalt/loader/image/image_data_decoder.cc b/src/cobalt/loader/image/image_data_decoder.cc
index af95b3b..a7a1920 100644
--- a/src/cobalt/loader/image/image_data_decoder.cc
+++ b/src/cobalt/loader/image/image_data_decoder.cc
@@ -67,8 +67,13 @@
}
size_t decoded_size = DecodeChunkInternal(input_bytes, input_size);
- size_t undecoded_size = input_size - decoded_size;
+ if (decoded_size == 0 && offset < size) {
+ LOG(ERROR) << "Unable to make progress decoding image.";
+ state_ = kError;
+ return;
+ }
+ size_t undecoded_size = input_size - decoded_size;
if (undecoded_size == 0) {
// Remove all elements from the data_buffer.
data_buffer_.clear();
diff --git a/src/cobalt/loader/image/image_decoder_test.cc b/src/cobalt/loader/image/image_decoder_test.cc
index 7f995fc..fda87ed 100644
--- a/src/cobalt/loader/image/image_decoder_test.cc
+++ b/src/cobalt/loader/image/image_decoder_test.cc
@@ -674,7 +674,7 @@
thread.Stop();
// The image should contain the whole undecoded data from the file.
- EXPECT_EQ(3224674u, animated_webp_image->GetEstimatedSizeInBytes());
+ EXPECT_EQ(4261474u, animated_webp_image->GetEstimatedSizeInBytes());
EXPECT_EQ(math::Size(480, 270), animated_webp_image->GetSize());
EXPECT_TRUE(animated_webp_image->IsOpaque());
@@ -705,7 +705,7 @@
thread.Stop();
// The image should contain the whole undecoded data from the file.
- EXPECT_EQ(3224674u, animated_webp_image->GetEstimatedSizeInBytes());
+ EXPECT_EQ(4261474u, animated_webp_image->GetEstimatedSizeInBytes());
EXPECT_EQ(math::Size(480, 270), animated_webp_image->GetSize());
EXPECT_TRUE(animated_webp_image->IsOpaque());
diff --git a/src/cobalt/loader/image/webp_image_decoder.cc b/src/cobalt/loader/image/webp_image_decoder.cc
index d587e79..5c803bc 100644
--- a/src/cobalt/loader/image/webp_image_decoder.cc
+++ b/src/cobalt/loader/image/webp_image_decoder.cc
@@ -87,8 +87,20 @@
if (status == VP8_STATUS_OK) {
DCHECK(image_data());
DCHECK(config_.output.u.RGBA.rgba);
- SbMemoryCopy(image_data()->GetMemory(), config_.output.u.RGBA.rgba,
- config_.output.u.RGBA.size);
+
+ // Copy the image data over line by line. We copy line by line instead
+ // of all at once so that we can adjust for differences in pitch between
+ // source and destination buffers.
+ uint8* cur_src = config_.output.u.RGBA.rgba;
+ uint8* cur_dest = image_data()->GetMemory();
+ int height = image_data()->GetDescriptor().size.height();
+ int num_pixel_bytes = image_data()->GetDescriptor().size.width() * 4;
+ for (int i = 0; i < height; ++i) {
+ SbMemoryCopy(cur_dest, cur_src, num_pixel_bytes);
+ cur_src += config_.output.u.RGBA.stride;
+ cur_dest += image_data()->GetDescriptor().pitch_in_bytes;
+ }
+
set_state(kDone);
} else if (status != VP8_STATUS_SUSPENDED) {
DLOG(ERROR) << "WebPIAppend error, status code: " << status;
@@ -135,10 +147,6 @@
config_.output.colorspace = pixel_format() == render_tree::kPixelFormatRGBA8
? (has_alpha ? MODE_rgbA : MODE_RGBA)
: (has_alpha ? MODE_bgrA : MODE_BGRA);
- config_.output.u.RGBA.stride = image_data()->GetDescriptor().pitch_in_bytes;
- config_.output.u.RGBA.size =
- static_cast<size_t>(config_.output.u.RGBA.stride *
- image_data()->GetDescriptor().size.height());
// We don't use image buffer as the decoding buffer because libwebp will read
// from it while we assume that our image buffer is write only.
config_.output.is_external_memory = 0;
diff --git a/src/cobalt/network/network_module.cc b/src/cobalt/network/network_module.cc
index bb4e074..f9fb043 100644
--- a/src/cobalt/network/network_module.cc
+++ b/src/cobalt/network/network_module.cc
@@ -122,6 +122,7 @@
base::Thread::Options thread_options;
thread_options.message_loop_type = MessageLoop::TYPE_IO;
thread_options.stack_size = 256 * 1024;
+ thread_options.priority = base::kThreadPriority_High;
thread_->StartWithOptions(thread_options);
base::WaitableEvent creation_event(true, false);
diff --git a/src/cobalt/renderer/backend/egl/graphics_context.cc b/src/cobalt/renderer/backend/egl/graphics_context.cc
index 5564bcd..6255fc7 100644
--- a/src/cobalt/renderer/backend/egl/graphics_context.cc
+++ b/src/cobalt/renderer/backend/egl/graphics_context.cc
@@ -274,8 +274,13 @@
// with eglMakeCurrent to avoid polluting the previous EGLSurface target.
DCHECK_NE(surface->GetPlatformHandle(), 0);
- egl_surface = null_surface_->GetSurface();
- EGL_CALL(eglMakeCurrent(display_, egl_surface, egl_surface, context_));
+ // Since we don't care about what surface is backing the default
+ // framebuffer, don't change draw surfaces unless we simply don't have one
+ // already.
+ if (!IsCurrent()) {
+ egl_surface = null_surface_->GetSurface();
+ EGL_CALL(eglMakeCurrent(display_, egl_surface, egl_surface, context_));
+ }
GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, surface->GetPlatformHandle()));
}
@@ -289,7 +294,12 @@
}
void GraphicsContextEGL::MakeCurrent() {
- MakeCurrentWithSurface(null_surface_);
+ // Some GL drivers do *not* handle switching contexts in the middle of a
+ // frame very well, so with this change we avoid making a new surface
+ // current if we don't actually care about what surface is current.
+ if (!IsCurrent()) {
+ MakeCurrentWithSurface(null_surface_);
+ }
}
void GraphicsContextEGL::ReleaseCurrentContext() {
diff --git a/src/cobalt/renderer/backend/egl/graphics_context.h b/src/cobalt/renderer/backend/egl/graphics_context.h
index 49e7c60..ef88e66 100644
--- a/src/cobalt/renderer/backend/egl/graphics_context.h
+++ b/src/cobalt/renderer/backend/egl/graphics_context.h
@@ -113,6 +113,9 @@
void Blit(GLuint texture, int x, int y, int width, int height);
+ // Returns if this graphics context is current on the calling thread or not.
+ bool IsCurrent() const { return is_current_; }
+
private:
// Performs a test to determine if the pixel data returned by glReadPixels
// needs to be vertically flipped or not. This test is expensive, so it
diff --git a/src/cobalt/renderer/rasterizer/blitter/image.cc b/src/cobalt/renderer/rasterizer/blitter/image.cc
index f51569e..21a6b1c 100644
--- a/src/cobalt/renderer/rasterizer/blitter/image.cc
+++ b/src/cobalt/renderer/rasterizer/blitter/image.cc
@@ -96,7 +96,8 @@
SubmitOffscreenCallback submit_offscreen_callback, SbBlitterDevice device)
: size_(static_cast<int>(root->GetBounds().right()),
static_cast<int>(root->GetBounds().bottom())),
- is_opaque_(false) {
+ is_opaque_(false),
+ surface_(kSbBlitterInvalidSurface) {
initialize_image_ = base::Bind(
&SinglePlaneImage::InitializeImageFromRenderTree, base::Unretained(this),
root, submit_offscreen_callback, device);
diff --git a/src/cobalt/renderer/rasterizer/blitter/render_tree_node_visitor.cc b/src/cobalt/renderer/rasterizer/blitter/render_tree_node_visitor.cc
index 4a95847..3defd2e 100644
--- a/src/cobalt/renderer/rasterizer/blitter/render_tree_node_visitor.cc
+++ b/src/cobalt/renderer/rasterizer/blitter/render_tree_node_visitor.cc
@@ -190,6 +190,11 @@
void RenderTreeNodeVisitor::Visit(render_tree::ImageNode* image_node) {
TRACE_EVENT0_IF_ENABLED("Visit(ImageNode)");
+ // The image_node may contain nothing. For example, when it represents a video
+ // or other kind of animated image element before any frame is decoded.
+ if (!image_node->data().source) {
+ return;
+ }
// All Blitter API images derive from skia::Image (so that they can be
// compatible with the Skia software renderer), so we start here by casting
diff --git a/src/cobalt/renderer/rasterizer/pixel_test.cc b/src/cobalt/renderer/rasterizer/pixel_test.cc
index fb95695..192010c 100644
--- a/src/cobalt/renderer/rasterizer/pixel_test.cc
+++ b/src/cobalt/renderer/rasterizer/pixel_test.cc
@@ -3405,6 +3405,12 @@
#endif // defined(ENABLE_MAP_TO_MESH)
+TEST_F(PixelTest, DrawNullImage) {
+ // An ImageNode with no source is legal, though it should result in nothing
+ // being drawn.
+ TestTree(new ImageNode(NULL, math::RectF(output_surface_size())));
+}
+
} // namespace rasterizer
} // namespace renderer
} // namespace cobalt
diff --git a/src/cobalt/renderer/rasterizer/skia/hardware_image.cc b/src/cobalt/renderer/rasterizer/skia/hardware_image.cc
index 5eafdd2..6332261 100644
--- a/src/cobalt/renderer/rasterizer/skia/hardware_image.cc
+++ b/src/cobalt/renderer/rasterizer/skia/hardware_image.cc
@@ -320,9 +320,16 @@
backend::GraphicsContextEGL* cobalt_context, GrContext* gr_context) {
DCHECK_EQ(rasterizer_message_loop_, MessageLoop::current());
+ backend::GraphicsContextEGL::ScopedMakeCurrent scoped_make_current(
+ cobalt_context);
+
scoped_refptr<backend::FramebufferRenderTargetEGL> render_target(
new backend::FramebufferRenderTargetEGL(cobalt_context, size_));
+ // The above call to FramebufferRenderTargetEGL() may have dirtied graphics
+ // state, so tell Skia to reset its context.
+ gr_context->resetContext(kRenderTarget_GrGLBackendState |
+ kTextureBinding_GrGLBackendState);
submit_offscreen_callback.Run(root, render_target);
scoped_ptr<backend::TextureEGL> texture(
@@ -330,6 +337,11 @@
backend_image_.reset(new HardwareBackendImage(texture.Pass()));
backend_image_->CommonInitialize(gr_context);
+
+ // Tell Skia that the graphics state is unknown because we issued custom
+ // GL commands above.
+ gr_context->resetContext(kRenderTarget_GrGLBackendState |
+ kTextureBinding_GrGLBackendState);
}
HardwareMultiPlaneImage::HardwareMultiPlaneImage(
diff --git a/src/cobalt/renderer/rasterizer/skia/hardware_rasterizer.cc b/src/cobalt/renderer/rasterizer/skia/hardware_rasterizer.cc
index 471f5cd..1af8965 100644
--- a/src/cobalt/renderer/rasterizer/skia/hardware_rasterizer.cc
+++ b/src/cobalt/renderer/rasterizer/skia/hardware_rasterizer.cc
@@ -560,6 +560,17 @@
const scoped_refptr<backend::RenderTarget>& render_target) {
DCHECK(thread_checker_.CalledOnValidThread());
+ scoped_refptr<backend::RenderTargetEGL> render_target_egl(
+ base::polymorphic_downcast<backend::RenderTargetEGL*>(
+ render_target.get()));
+
+ if (render_target_egl->is_surface_bad()) {
+ return;
+ }
+
+ backend::GraphicsContextEGL::ScopedMakeCurrent scoped_make_current(
+ graphics_context_, render_target_egl);
+
// Create a canvas from the render target.
GrBackendRenderTargetDesc skia_desc =
CobaltRenderTargetToSkiaBackendRenderTargetDesc(render_target.get());
diff --git a/src/cobalt/renderer/rasterizer/testdata/DrawNullImage-expected.png b/src/cobalt/renderer/rasterizer/testdata/DrawNullImage-expected.png
new file mode 100644
index 0000000..7f0bfcf
--- /dev/null
+++ b/src/cobalt/renderer/rasterizer/testdata/DrawNullImage-expected.png
Binary files differ
diff --git a/src/cobalt/webdriver_benchmarks/README.md b/src/cobalt/webdriver_benchmarks/README.md
deleted file mode 100644
index da77083..0000000
--- a/src/cobalt/webdriver_benchmarks/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-Framework for webdriver-driven benchmarks.
-
-Please see tests/README.md
diff --git a/src/cobalt/webdriver_benchmarks/__init__.py b/src/cobalt/webdriver_benchmarks/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/src/cobalt/webdriver_benchmarks/__init__.py
+++ /dev/null
diff --git a/src/cobalt/webdriver_benchmarks/c_val_names.py b/src/cobalt/webdriver_benchmarks/c_val_names.py
deleted file mode 100644
index 6ce4f4d..0000000
--- a/src/cobalt/webdriver_benchmarks/c_val_names.py
+++ /dev/null
@@ -1,89 +0,0 @@
-"""Provides cval names needed by the webdriver benchmarks."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-
-def count_dom_active_java_script_events():
- return "Count.DOM.ActiveJavaScriptEvents"
-
-
-def count_dom_html_elements_document():
- return "Count.MainWebModule.DOM.HtmlElement.Document"
-
-
-def count_dom_html_elements_total():
- return "Count.MainWebModule.DOM.HtmlElement.Total"
-
-
-def count_dom_html_script_element_execute():
- return "Count.MainWebModule.DOM.HtmlScriptElement.Execute"
-
-
-def count_layout_boxes():
- return "Count.MainWebModule.Layout.Box"
-
-
-def count_image_cache_loading_resources():
- return "Count.MainWebModule.ImageCache.LoadingResources"
-
-
-def count_image_cache_requested_resources():
- return "Count.MainWebModule.ImageCache.RequestedResources"
-
-
-def count_rasterize_new_render_tree():
- return "Count.Renderer.Rasterize.NewRenderTree"
-
-
-def event_duration_dom_video_start_delay():
- return "Event.Duration.MainWebModule.DOM.VideoStartDelay"
-
-
-def event_is_processing():
- return "Event.MainWebModule.IsProcessing"
-
-
-def event_value_dictionary(event_type):
- return "Event.MainWebModule.{}.ValueDictionary".format(event_type)
-
-
-def layout_is_dirty():
- return "MainWebModule.Layout.IsDirty"
-
-
-def rasterize_animations_entry_list():
- return "Renderer.Rasterize.Animations.EntryList"
-
-
-def renderer_has_active_animations():
- return "Renderer.HasActiveAnimations"
-
-
-def time_browser_navigate():
- return "Time.Browser.Navigate"
-
-
-def time_browser_on_load_event():
- return "Time.Browser.OnLoadEvent"
-
-
-def time_cobalt_start():
- return "Time.Cobalt.Start"
-
-
-def time_dom_html_script_element_execute():
- return "Time.MainWebModule.DOM.HtmlScriptElement.Execute"
-
-
-def time_rasterize_animations_start():
- return "Time.Renderer.Rasterize.Animations.Start"
-
-
-def time_rasterize_animations_end():
- return "Time.Renderer.Rasterize.Animations.End"
-
-
-def time_rasterize_new_render_tree():
- return "Time.Renderer.Rasterize.NewRenderTree"
diff --git a/src/cobalt/webdriver_benchmarks/container_util.py b/src/cobalt/webdriver_benchmarks/container_util.py
deleted file mode 100644
index 56e948a..0000000
--- a/src/cobalt/webdriver_benchmarks/container_util.py
+++ /dev/null
@@ -1,54 +0,0 @@
-"""Base class for WebDriver tests."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import math
-
-
-def mean(list_values):
- """Returns the mean of a list of numeric values.
-
- Args:
- list_values: A list of numeric values.
- Returns:
- Appropriate value.
- """
- if not list_values:
- return None
-
- return sum(list_values) / len(list_values)
-
-
-def percentile(list_values, target_percentile):
- """Returns the percentile of a list.
-
- This method interpolates between two numbers if the percentile lands between
- two data points.
-
- Args:
- list_values: A sortable list of values
- target_percentile: A number ranging from 0-100.
- Returns:
- Appropriate value.
- Raises:
- RuntimeError: Raised on invalid args.
- """
- if not list_values:
- return None
- if target_percentile > 100 or target_percentile < 0:
- raise RuntimeError("target_percentile must be 0-100")
- sorted_values = sorted(list_values)
-
- if target_percentile == 100:
- return sorted_values[-1]
- fractional, index = math.modf(
- (len(sorted_values) - 1) * (target_percentile * 0.01))
- index = int(index)
-
- if len(sorted_values) == index + 1:
- return sorted_values[index]
-
- return sorted_values[index] * (
- 1 - fractional) + sorted_values[index + 1] * fractional
diff --git a/src/cobalt/webdriver_benchmarks/container_util_test.py b/src/cobalt/webdriver_benchmarks/container_util_test.py
deleted file mode 100755
index 8c29bb4..0000000
--- a/src/cobalt/webdriver_benchmarks/container_util_test.py
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/python2
-# Copyright 2016 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-"""Unit tests for tv_testcase.py."""
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-import unittest
-
-# This directory is a package
-sys.path.insert(0, os.path.abspath('.'))
-# pylint: disable=C6203,C6203
-# pylint: disable=g-import-not-at-top
-import container_util
-
-
-class MeanTest(unittest.TestCase):
-
- def test_empty_case(self):
- self.assertEqual(container_util.mean([]), None)
-
- def test_one_item(self):
- self.assertEqual(container_util.mean([1]), 1)
-
- def test_two_items(self):
- self.assertAlmostEqual(container_util.mean([4, 1]), 2.5)
-
- def test_three_items(self):
- self.assertAlmostEqual(container_util.mean([4, -4, 9]), 3)
-
- def test_four_items(self):
- self.assertAlmostEqual(container_util.mean([6, 0, 1, -2]), 1.25)
-
-
-class MedianPercentileTest(unittest.TestCase):
-
- def test_empty_case(self):
- self.assertEqual(container_util.percentile([], 50), None)
-
- def test_one_item(self):
- self.assertEqual(container_util.percentile([1], 50), 1)
-
- def test_two_items(self):
- self.assertAlmostEqual(container_util.percentile([4, 1], 50), 2.5)
-
- def test_three_items(self):
- self.assertAlmostEqual(container_util.percentile([4, -4, -2], 50), -2)
-
- def test_four_items(self):
- self.assertAlmostEqual(container_util.percentile([4, 0, 1, -2], 50), 0.5)
-
-
-class PercentileTest(unittest.TestCase):
-
- def test_one_item(self):
- self.assertEqual(container_util.percentile([1], 10), 1)
- self.assertEqual(container_util.percentile([2], 50), 2)
- self.assertEqual(container_util.percentile([3], 90), 3)
-
- def test_two_items(self):
- self.assertEqual(container_util.percentile([2, 1], 10), 1.1)
- self.assertEqual(container_util.percentile([2, 3], 50), 2.5)
- self.assertEqual(container_util.percentile([3, 4], 90), 3.9)
- self.assertEqual(container_util.percentile([3, 4], 100), 4)
-
- def test_five_items(self):
- self.assertEqual(container_util.percentile([2, 1, 3, 4, 5], 10), 1.4)
- self.assertEqual(container_util.percentile([2, 1, 3, 4, 5], 50), 3)
- self.assertEqual(container_util.percentile([2, 1, 3, 4, 5], 90), 4.6)
- self.assertEqual(container_util.percentile([2, 1, 3, 4, 5], 100), 5)
-
-
-if __name__ == '__main__':
- sys.exit(unittest.main())
diff --git a/src/cobalt/webdriver_benchmarks/default_query_param_constants.py b/src/cobalt/webdriver_benchmarks/default_query_param_constants.py
deleted file mode 100644
index c2347f2..0000000
--- a/src/cobalt/webdriver_benchmarks/default_query_param_constants.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""Default query params to use when loading URLs."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-BASE_QUERY_PARAMS = {}
-
-INIT_QUERY_PARAMS = {}
-INIT_QUERY_PARAMS_TRIGGER_RELOAD = False
diff --git a/src/cobalt/webdriver_benchmarks/tests/README.md b/src/cobalt/webdriver_benchmarks/tests/README.md
deleted file mode 100644
index 81fde36..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/README.md
+++ /dev/null
@@ -1,292 +0,0 @@
-# Cobalt Webdriver-driven Benchmarks
-
-This directory contains a set of webdriver-driven benchmarks
-for Cobalt.
-
-Each file should contain a set of tests in Python "unittest" format.
-
-All tests included within [performance.py](performance.py) will be run on the
-build system. Results can be recorded in the build results database.
-
-## Running the tests
-
-In most cases, you will want to run all performance tests, and you can do so by
-executing the script [performance.py](performance.py). You can call
-`python performance.py --help` to see a list of commandline parameters to call
-it with. For example, to run tests on the raspi-2 QA build, you should run the
-following command:
-
-```
-python performance.py -p raspi-2 -c qa -d $RASPI_ADDR
-```
-
-Where `RASPI_ADDR` is set to the IP of the target Raspberry Pi device.
-
-To run individual tests, simply execute the script directly. For all tests,
-platform configuration will be inferred from the environment if set. Otherwise,
-it must be specified via commandline parameters.
-
-## Creating a new test
-
- 1. If appropriate, create a new file borrowing the boilerplate from
- an existing simple file, such as
- [browse_horizontal.py](performance/non_video/browse_horizontal.py).
-
- 2. Add the file name to the tests added within
- [performance.py](performance.py), causing it run when
- [performance](performance.py) is run.
-
- 3. If this file contains internal names or details, consider adding it
- to the "EXCLUDE.FILES" list.
-
- 4. Use the `record_test_result*` methods in `tv_testcase_util` where
- appropriate.
-
- 5. Results must be added to the build results database schema. See
- the internal
- [README-Updating-Result-Schema.md](README-Updating-Result-Schema.md) file.
-
-## Testing against specific loaders/labels
-
-To run the benchmarks against any desired loader, a --url command line parameter
-can be provided. This will be the url that the tests will run against.
-
-It should have the following format:
-
-```
-python performance.py -p raspi-2 -c qa -d $RASPI_ADDR --url https://www.youtube.com/tv?loader=nllive
-```
-
-## Benchmark Results
-
-The results will be printed to stdout. You should redirect output to a file
-if you would like to store the results. Each line of the benchmark output
-prefixed with `webdriver_benchmark TEST_RESULT:` provides the result of one
-measurment. Those lines have the following format:
-
-```
-webdriver_benchmark TEST_RESULT: result_name result_value
-```
-
-where `result_name` is the name of the result and `result_value` is a number
-providing the measured result for that metric. For example,
-
-```
-webdriver_benchmark TEST RESULT: wbBrowseHorizontalDurLayoutBoxTreeUpdateUsedSizesUsPct50 3061.5
-```
-
-gives the 50th percentile of the duration Cobalt took to update the box tree's
-used sizes, on a horizontal scroll event, in microseconds.
-
-Note that most time-based measurements are in microseconds.
-
-### Interesting Timing-Related Benchmarks
-Some particularly interesting timing-related benchmark results are:
-
-#### Startup
- - `wbStartupDurLaunchToBrowseUs`: Measures the time it takes to launch Cobalt
- and load the desired URL. The measurement ends when all images finish loading
- and the final render tree is produced. This is only run once so it will be
- noiser than other values but provides the most accurate measurement of the
- requirement startup time.
- - `wbStartupDurLaunchToUsableUs`: Measures the time it takes to launch Cobalt,
- and fully load the desired URL, including loading all scripts. The
- measurement ends when the Player JavaScript code finishes loading on the
- Browse page, which is the point when Cobalt is fully usable. This is only run
- once so it will be noiser than other values but provides the most accurate
- measurement of the time when Cobalt is usable.
- - `wbStartupDurNavigateToBrowseUs*`: Measures the time it takes to navigate to
- the desired URL when Cobalt is already loaded. The measurement ends when all
- images finish loading and the final render tree is produced. This is run
- multiple times, so it will be less noisy than `wbStartupDurLaunchToBrowseUs`,
- but it does not include Cobalt initialization so it is not as accurate of a
- measurement.
- - `wbStartupDurNavigateToUsableUs`: Measures the time it takes to navigate to
- the desired URL when Cobalt is already loaded, including loading all scripts.
- The measurement ends when the Player JavaScript code finishes loading on the
- Browse page, which is the point when Cobalt is fully usable. This is run
- multiple times, so it will be less noisy than `wbStartupDurLaunchToUsableUs`,
- but it does not include Cobalt initialization so it is not as accurate of a
- measurement.
-
-#### Browse Horizontal Scroll Events
- - `wbBrowseHorizontalDurTotalUs*`: Measures the latency (i.e. JavaScript
- execution time + layout time) during horizontal scroll events from keypress
- until the render tree is submitted to the rasterize thread. It does not
- include the time taken to rasterize the render tree so it will be smaller
- than the observed latency.
- - `wbBrowseHorizontalDurAnimationsStartDelayUs*`: Measures the input latency
- during horizontal scroll events from the keypress until the animation starts.
- This is the most accurate measure of input latency.
- - `wbBrowseHorizontalDurAnimationsEndDelayUs*`: Measures the latency during
- horizontal scroll events from the keypress until the animation ends.
- - `wbBrowseHorizontalDurFinalRenderTreeDelayUs*`: Measures the latency during
- horizontal scroll events from the keypress until the final render tree is
- rendered and processing stops.
- - `wbBrowseHorizontalDurRasterizeAnimationsUs*`: Measures the time it takes to
- render each frame of the animation triggered by a horizontal scroll event.
- The inverse of this number is the framerate.
-
-#### Browse Vertical Scroll Events
- - `wbBrowseVerticalDurTotalUs*`: Measures the latency (i.e. JavaScript
- execution time + layout time) during vertical scroll events from keypress
- until the render tree is submitted to the rasterize thread. It does not
- include the time taken to rasterize the render tree so it will be smaller
- than the observed latency.
- - `wbBrowseVerticalDurAnimationsStartDelayUs*`: Measures the input latency
- during vertical scroll events from the keypress until the animation starts.
- This is the most accurate measure of input latency.
- - `wbBrowseVerticalDurAnimationsEndDelayUs*`: Measures the latency during
- vertical scroll events from the keypress until the animation ends.
- - `wbBrowseVerticalDurFinalRenderTreeDelayUs*`: Measures the latency during
- vertical scroll events from the keypress until the final render tree is
- rendered and processing stops.
- - `wbBrowseVerticalDurRasterizeAnimationsUs*`: Measures the time it takes to
- render each frame of the animation triggered by a vertical scroll event.
- The inverse of this number is the framerate.
-
-#### Browse-to-Watch
- - `wbBrowseToWatchDurVideoStartDelay*`: Measures the browse-to-watch time.
-
-In each case above, the `*` symbol can be one of either `Mean`, `Pct25`,
-`Pct50`, `Pct75` or `Pct95`. For example, `wbStartupDurBlankToBrowseUsMean` or
-`wbStartupDurBlankToBrowseUsPct95` are both valid measurements. The webdriver
-benchmarks runs its tests many times in order to obtain multiple samples, so you
-can drill into the data by exploring either the mean, or the various
-percentiles.
-
-### Interesting Count-Related Benchmarks
-Some particularly interesting count-related benchmark results are:
-
-#### Startup
- - `wbStartupCntDomHtmlElements*`: Lists the number of HTML elements in
- existence after startup completes. This includes HTML elements that are no
- longer in the DOM but have not been garbage collected yet.
- - `wbStartupCntDocumentDomHtmlElements*`: Lists the number of HTML
- elements within the DOM tree after startup completes.
- - `wbStartupCntLayoutBoxes*`: Lists the number of layout boxes within
- the layout tree after startup completes.
- - `wbStartupCntRenderTrees*`: Lists the number of render trees that were
- generated during startup.
- - `wbStartupCntRequestedImages*`: Lists the number of images that were
- requested during startup.
-
-#### Browse Horizontal Scroll Events
- - `wbBrowseHorizontalCntDomHtmlElements*`: Lists the number of HTML elements in
- existence after the event. This includes HTML elements that are no longer in
- the DOM but have not been garbage collected yet.
- - `wbBrowseHorizontalCntDocumentDomHtmlElements*`: Lists the number of HTML
- elements within the DOM tree after the event.
- - `wbBrowseHorizontalCntLayoutBoxes*`: Lists the number of layout boxes within
- the layout tree after the event.
- - `wbBrowseHorizontalCntLayoutBoxesCreated*`: Lists the number of new layout
- boxes that were created during the event.
- - `wbBrowseHorizontalCntRenderTrees*`: Lists the number of render trees that
- were generated by the event.
- - `wbBrowseHorizontalCntRequestedImages*`: Lists the number of images that were
- requested as a result of the event.
-
-#### Browse Vertical Scroll Events
- - `wbBrowseVerticalCntDomHtmlElements*`: Lists the number of HTML elements in
- existence after the event. This includes HTML elements that are no longer in
- the DOM but have not been garbage collected yet.
- - `wbBrowseVerticalCntDocumentDomHtmlElements*`: Lists the number of HTML
- elements within the DOM tree after the event.
- - `wbBrowseVerticalCntLayoutBoxes*`: Lists the number of layout boxes within
- the layout tree after the event.
- - `wbBrowseVerticalCntLayoutBoxesCreated*`: Lists the number of new layout
- boxes that were created during the event.
- - `wbBrowseVerticalCntRenderTrees*`: Lists the number of render trees that
- were generated by the event.
- - `wbBrowseVerticalCntRequestedImages*`: Lists the number of images that were
- requested as a result of the event.
-
-In each case above, the `*` symbol can be one of either `Max`, `Median`, or
-`Mean`. For example, `wbBrowseVerticalCntDomHtmlElementsMax` or
-`wbBrowseVerticalCntDomHtmlElementsMedian` are both valid measurements. The
-webdriver benchmarks runs its tests many times in order to obtain multiple
-samples, so you can drill into the data by exploring either the max, median, or
-mean.
-
-### Filtering results
-
-The webdriver benchmarks output many metrics, but you may only be interested
-in a few. You will have to manually filter only the metrics that you are
-interested in. You can do so with `grep`, for example:
-
-```
-python performance.py -p raspi-2 -c qa -d $RASPI_ADDR > results.txt
-echo "" > filtered_results.txt
-printf "=================================TIMING-RELATED=================================\n" >> filtered_results.txt
-printf "\nSTARTUP\n" >> filtered_results.txt
-grep -o "wbStartupDurLaunchToBrowseUs.*$" results.txt >> filtered_results.txt
-grep -o "wbStartupDurLaunchToUsableUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbStartupDurNavigateToBrowseUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbStartupDurNavigateToUsableUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-printf "\nBROWSE HORIZONTAL SCROLL EVENTS\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalDurTotalUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalDurAnimationsStartDelayUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalDurAnimationsEndDelayUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalDurFinalRenderTreeDelayUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalDurRasterizeAnimationsUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-printf "\nBROWSE VERTICAL SCROLL EVENTS\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalDurTotalUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalDurAnimationsStartDelayUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalDurAnimationsEndDelayUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalDurFinalRenderTreeDelayUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalDurRasterizeAnimationsUs.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-printf "\nBROWSE TO WATCH\n" >> filtered_results.txt
-grep -o "wbBrowseToWatchDurVideoStartDelay.*$" results.txt >> filtered_results.txt
-printf "\n\n=================================COUNT-RELATED==================================\n" >> filtered_results.txt
-printf "\nSTARTUP\n" >> filtered_results.txt
-grep -o "wbStartupCntDomHtmlElements.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbStartupCntDomDocumentHtmlElements.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbStartupCntLayoutBoxes.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbStartupCntRenderTrees.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbStartupCntRequestedImages.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-printf "\nBROWSE HORIZONTAL SCROLL EVENTS\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalCntDomHtmlElementsM.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalCntDomDocumentHtmlElements.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalCntLayoutBoxesM.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalCntLayoutBoxesCreated.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalCntRenderTrees.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseHorizontalCntRequestedImages.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-printf "\nBROWSE VERTICAL SCROLL EVENTS\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalCntDomHtmlElementsM.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalCntDomDocumentHtmlElements.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalCntLayoutBoxesM.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalCntLayoutBoxesCreated.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalCntRenderTrees.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-grep -o "wbBrowseVerticalCntRequestedImages.*$" results.txt >> filtered_results.txt
-printf "\n" >> filtered_results.txt
-cat filtered_results.txt
-```
diff --git a/src/cobalt/webdriver_benchmarks/tests/__init__.py b/src/cobalt/webdriver_benchmarks/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/__init__.py
+++ /dev/null
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance.py b/src/cobalt/webdriver_benchmarks/tests/performance.py
deleted file mode 100644
index 8495f71..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/python2
-"""Target for running all performance test cases."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import importlib
-import os
-import sys
-import unittest
-
-# The parent directory is a module
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
-
-# pylint: disable=C6204,C6203
-import tv_testcase
-
-
-def _add_test(test_suite, dir_path, test_name):
- if os.path.isfile(os.path.join(dir_path, test_name + ".py")):
- print("Adding test: {}".format(test_name))
- test_suite.addTest(unittest.TestLoader().loadTestsFromModule(
- importlib.import_module("tests." + test_name)))
-
-
-# pylint: disable=unused-argument
-def load_tests(loader, tests, pattern):
- """This is a Python unittest "load_tests protocol method."""
- test_suite = unittest.TestSuite()
- dir_path = os.path.dirname(__file__)
-
- _add_test(test_suite, dir_path, "performance_non_video")
- _add_test(test_suite, dir_path, "performance_video")
-
- return test_suite
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/__init__.py b/src/cobalt/webdriver_benchmarks/tests/performance/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/__init__.py
+++ /dev/null
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/__init__.py b/src/cobalt/webdriver_benchmarks/tests/performance/non_video/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/__init__.py
+++ /dev/null
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_horizontal.py b/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_horizontal.py
deleted file mode 100755
index 2da83c6..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_horizontal.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/python2
-"""Simple benchmark of horizontally navigating shelves during browse."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-
-# Add the base webdriver_benchmarks path
-sys.path.insert(0,
- os.path.dirname(
- os.path.dirname((os.path.dirname(
- os.path.dirname(os.path.realpath(__file__)))))))
-
-# pylint: disable=C6204,C6203
-import tv_testcase
-import tv_testcase_event_recorder
-import tv_testcase_util
-
-# selenium imports
-keys = tv_testcase_util.import_selenium_module("webdriver.common.keys")
-
-NUM_LOAD_TV_CALLS = 5
-NUM_ITERATIONS_PER_LOAD_TV_CALL = 20
-
-BROWSE_HORIZONTAL_EVENT_NAME = "wbBrowseHorizontal"
-BROWSE_HORIZONTAL_EVENT_TYPE = tv_testcase_util.EVENT_TYPE_KEY_DOWN
-
-
-class BrowseHorizontalTest(tv_testcase.TvTestCase):
-
- def test_simple(self):
- recorder_options = tv_testcase_event_recorder.EventRecorderOptions(
- self, BROWSE_HORIZONTAL_EVENT_NAME, BROWSE_HORIZONTAL_EVENT_TYPE)
- recorder = tv_testcase_event_recorder.EventRecorder(recorder_options)
-
- for _ in xrange(NUM_LOAD_TV_CALLS):
- self.load_tv()
- self.send_keys(keys.Keys.ARROW_RIGHT)
- self.wait_for_processing_complete_after_focused_shelf()
-
- for _ in xrange(NUM_ITERATIONS_PER_LOAD_TV_CALL):
- recorder.on_start_event()
- self.send_keys(keys.Keys.ARROW_RIGHT)
- self.wait_for_processing_complete_after_focused_shelf()
- recorder.on_end_event()
-
- recorder.on_end_test()
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_to_guide.py b/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_to_guide.py
deleted file mode 100755
index 7e5230f..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_to_guide.py
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/usr/bin/python2
-"""Simple benchmark for going from browse to guide and back."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-
-# Add the base webdriver_benchmarks path
-sys.path.insert(0,
- os.path.dirname(
- os.path.dirname((os.path.dirname(
- os.path.dirname(os.path.realpath(__file__)))))))
-
-# pylint: disable=C6204,C6203
-import tv
-import tv_testcase
-import tv_testcase_event_recorder
-import tv_testcase_util
-
-# selenium imports
-keys = tv_testcase_util.import_selenium_module("webdriver.common.keys")
-
-NUM_LOAD_TV_CALLS = 1
-NUM_ITERATIONS_PER_LOAD_TV_CALL = 20
-
-BROWSE_TO_GUIDE_EVENT_NAME = "wbBrowseToGuide"
-BROWSE_TO_GUIDE_EVENT_TYPE = tv_testcase_util.EVENT_TYPE_KEY_DOWN
-
-GUIDE_TO_BROWSE_EVENT_NAME = "wbGuideToBrowse"
-GUIDE_TO_BROWSE_EVENT_TYPE = tv_testcase_util.EVENT_TYPE_KEY_DOWN
-
-
-class BrowseToGuideTest(tv_testcase.TvTestCase):
-
- def test_simple(self):
- recorder_options = tv_testcase_event_recorder.EventRecorderOptions(
- self, BROWSE_TO_GUIDE_EVENT_NAME, BROWSE_TO_GUIDE_EVENT_TYPE)
- browse_to_guide_recorder = tv_testcase_event_recorder.EventRecorder(
- recorder_options)
-
- recorder_options = tv_testcase_event_recorder.EventRecorderOptions(
- self, GUIDE_TO_BROWSE_EVENT_NAME, GUIDE_TO_BROWSE_EVENT_TYPE)
- guide_to_browse_recorder = tv_testcase_event_recorder.EventRecorder(
- recorder_options)
-
- for _ in xrange(NUM_LOAD_TV_CALLS):
- self.load_tv()
-
- for _ in xrange(NUM_ITERATIONS_PER_LOAD_TV_CALL):
- browse_to_guide_recorder.on_start_event()
- self.send_keys(keys.Keys.ARROW_LEFT)
- self.wait_for_processing_complete()
- self.assert_displayed(tv.FOCUSED_GUIDE)
- browse_to_guide_recorder.on_end_event()
-
- guide_to_browse_recorder.on_start_event()
- self.send_keys(keys.Keys.ARROW_RIGHT)
- self.wait_for_processing_complete_after_focused_shelf()
- guide_to_browse_recorder.on_end_event()
-
- browse_to_guide_recorder.on_end_test()
- guide_to_browse_recorder.on_end_test()
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_to_search.py b/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_to_search.py
deleted file mode 100755
index a2d82de..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_to_search.py
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/usr/bin/python2
-"""Simple benchmark for going from browse to search and back."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-
-# Add the base webdriver_benchmarks path
-sys.path.insert(0,
- os.path.dirname(
- os.path.dirname((os.path.dirname(
- os.path.dirname(os.path.realpath(__file__)))))))
-
-# pylint: disable=C6204,C6203
-import tv
-import tv_testcase
-import tv_testcase_event_recorder
-import tv_testcase_util
-
-# selenium imports
-keys = tv_testcase_util.import_selenium_module("webdriver.common.keys")
-
-NUM_LOAD_TV_CALLS = 1
-NUM_ITERATIONS_PER_LOAD_TV_CALL = 20
-
-BROWSE_TO_SEARCH_EVENT_NAME = "wbBrowseToSearch"
-BROWSE_TO_SEARCH_EVENT_TYPE = tv_testcase_util.EVENT_TYPE_KEY_UP
-
-SEARCH_TO_BROWSE_EVENT_NAME = "wbSearchToBrowse"
-SEARCH_TO_BROWSE_EVENT_TYPE = tv_testcase_util.EVENT_TYPE_KEY_UP
-
-
-class BrowseToSearchTest(tv_testcase.TvTestCase):
-
- def test_simple(self):
- recorder_options = tv_testcase_event_recorder.EventRecorderOptions(
- self, BROWSE_TO_SEARCH_EVENT_NAME, BROWSE_TO_SEARCH_EVENT_TYPE)
- recorder_options.record_animations = False
- browse_to_search_recorder = tv_testcase_event_recorder.EventRecorder(
- recorder_options)
-
- recorder_options = tv_testcase_event_recorder.EventRecorderOptions(
- self, SEARCH_TO_BROWSE_EVENT_NAME, SEARCH_TO_BROWSE_EVENT_TYPE)
- recorder_options.record_animations = False
- search_to_browse_recorder = tv_testcase_event_recorder.EventRecorder(
- recorder_options)
-
- for _ in xrange(NUM_LOAD_TV_CALLS):
- self.load_tv()
-
- for _ in xrange(NUM_ITERATIONS_PER_LOAD_TV_CALL):
- browse_to_search_recorder.on_start_event()
- self.send_keys("s")
- self.wait_for_processing_complete(False)
- self.assert_displayed(tv.FOCUSED_SEARCH)
- browse_to_search_recorder.on_end_event()
-
- search_to_browse_recorder.on_start_event()
- self.send_keys(keys.Keys.ESCAPE)
- self.wait_for_processing_complete_after_focused_shelf()
- search_to_browse_recorder.on_end_event()
-
- browse_to_search_recorder.on_end_test()
- search_to_browse_recorder.on_end_test()
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_vertical.py b/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_vertical.py
deleted file mode 100755
index 08a687e..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/browse_vertical.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/python2
-"""Simple benchmark of vertically navigating shelves during browse."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-
-# Add the base webdriver_benchmarks path
-sys.path.insert(0,
- os.path.dirname(
- os.path.dirname((os.path.dirname(
- os.path.dirname(os.path.realpath(__file__)))))))
-
-# pylint: disable=C6204,C6203
-import tv_testcase
-import tv_testcase_event_recorder
-import tv_testcase_util
-
-# selenium imports
-keys = tv_testcase_util.import_selenium_module("webdriver.common.keys")
-
-NUM_LOAD_TV_CALLS = 4
-NUM_ITERATIONS_PER_LOAD_TV_CALL = 25
-
-BROWSE_VERTICAL_EVENT_NAME = "wbBrowseVertical"
-BROWSE_VERTICAL_EVENT_TYPE = tv_testcase_util.EVENT_TYPE_KEY_DOWN
-
-
-class BrowseVerticalTest(tv_testcase.TvTestCase):
-
- def test_simple(self):
- recorder_options = tv_testcase_event_recorder.EventRecorderOptions(
- self, BROWSE_VERTICAL_EVENT_NAME, BROWSE_VERTICAL_EVENT_TYPE)
- recorder = tv_testcase_event_recorder.EventRecorder(recorder_options)
-
- for _ in xrange(NUM_LOAD_TV_CALLS):
- self.load_tv()
- self.send_keys(keys.Keys.ARROW_DOWN)
- self.wait_for_processing_complete_after_focused_shelf()
-
- for _ in xrange(NUM_ITERATIONS_PER_LOAD_TV_CALL):
- recorder.on_start_event()
- self.send_keys(keys.Keys.ARROW_DOWN)
- self.wait_for_processing_complete_after_focused_shelf()
- recorder.on_end_event()
-
- recorder.on_end_test()
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/startup.py b/src/cobalt/webdriver_benchmarks/tests/performance/non_video/startup.py
deleted file mode 100755
index c37008e..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/non_video/startup.py
+++ /dev/null
@@ -1,164 +0,0 @@
-#!/usr/bin/python2
-"""Simple benchmark for measuring startup time."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-
-# Add the base webdriver_benchmarks path
-sys.path.insert(0,
- os.path.dirname(
- os.path.dirname((os.path.dirname(
- os.path.dirname(os.path.realpath(__file__)))))))
-
-# pylint: disable=C6204,C6203
-import c_val_names
-import tv_testcase
-import tv_testcase_util
-
-NUM_LOAD_TV_ITERATIONS = 20
-
-STARTUP_RECORD_NAME = "wbStartup"
-
-
-class StartupTest(tv_testcase.TvTestCase):
-
- def setUp(self):
- # Override TvTestCase's setUp() so that blank startup can first be measured.
- pass
-
- def test_simple(self):
- """This test tries to measure the startup time for the YouTube TV page."""
- self.wait_for_processing_complete()
- self.wait_for_html_script_element_execute_count(2)
-
- # Measure durations for the intial launch.
- launch_time = self.get_cval(c_val_names.time_cobalt_start())
- navigate_time = self.get_cval(c_val_names.time_browser_navigate())
- on_load_event_time = self.get_cval(c_val_names.time_browser_on_load_event())
- browse_time = self.get_cval(c_val_names.time_rasterize_new_render_tree())
- usable_time = self.get_cval(
- c_val_names.time_dom_html_script_element_execute())
-
- dur_launch_to_navigate_us = navigate_time - launch_time
- dur_launch_to_on_load_event_us = on_load_event_time - launch_time
- dur_launch_to_browse_us = browse_time - launch_time
- dur_launch_to_usable_us = usable_time - launch_time
-
- # Call TvTestCase's setUp() now that the launch times have been measured.
- super(StartupTest, self).setUp()
-
- # Count record strategies
- count_record_strategies = []
- count_record_strategies.append(tv_testcase_util.RecordStrategyMean())
- count_record_strategies.append(tv_testcase_util.RecordStrategyMin())
- count_record_strategies.append(tv_testcase_util.RecordStrategyMedian())
- count_record_strategies.append(tv_testcase_util.RecordStrategyMax())
-
- # Duration record strategies
- duration_record_strategies = []
- duration_record_strategies.append(tv_testcase_util.RecordStrategyMean())
- duration_record_strategies.append(tv_testcase_util.RecordStrategyMin())
- duration_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(25))
- duration_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(50))
- duration_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(75))
- duration_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(95))
- duration_record_strategies.append(tv_testcase_util.RecordStrategyMax())
-
- # Count recorders
- count_total_html_element_recorder = tv_testcase_util.ResultsRecorder(
- STARTUP_RECORD_NAME + "CntDomHtmlElements", count_record_strategies)
- count_document_html_element_recorder = tv_testcase_util.ResultsRecorder(
- STARTUP_RECORD_NAME + "CntDomDocumentHtmlElements",
- count_record_strategies)
- count_layout_box_recorder = tv_testcase_util.ResultsRecorder(
- STARTUP_RECORD_NAME + "CntLayoutBoxes", count_record_strategies)
- count_render_trees_recorder = tv_testcase_util.ResultsRecorder(
- STARTUP_RECORD_NAME + "CntRenderTrees", count_record_strategies)
- count_requested_images_recorder = tv_testcase_util.ResultsRecorder(
- STARTUP_RECORD_NAME + "CntRequestedImages", count_record_strategies)
-
- # Duration recorders
- duration_navigate_to_on_load_recorder = tv_testcase_util.ResultsRecorder(
- STARTUP_RECORD_NAME + "DurNavigateToOnLoadUs",
- duration_record_strategies)
- duration_navigate_to_browse_recorder = tv_testcase_util.ResultsRecorder(
- STARTUP_RECORD_NAME + "DurNavigateToBrowseUs",
- duration_record_strategies)
- duration_navigate_to_usable_recorder = tv_testcase_util.ResultsRecorder(
- STARTUP_RECORD_NAME + "DurNavigateToUsableUs",
- duration_record_strategies)
-
- # Now measure counts and durations from reloading the URL.
- for _ in range(NUM_LOAD_TV_ITERATIONS):
- count_render_trees_start = self.get_cval(
- c_val_names.count_rasterize_new_render_tree())
-
- self.load_tv()
-
- count_render_trees_end = self.get_cval(
- c_val_names.count_rasterize_new_render_tree())
-
- count_total_html_elements = self.get_cval(
- c_val_names.count_dom_html_elements_total())
- count_document_html_elements = self.get_cval(
- c_val_names.count_dom_html_elements_document())
- count_layout_boxes = self.get_cval(c_val_names.count_layout_boxes())
- count_requested_images = self.get_cval(
- c_val_names.count_image_cache_requested_resources())
-
- navigate_time = self.get_cval(c_val_names.time_browser_navigate())
- on_load_event_time = self.get_cval(
- c_val_names.time_browser_on_load_event())
- browse_time = self.get_cval(c_val_names.time_rasterize_new_render_tree())
- usable_time = self.get_cval(
- c_val_names.time_dom_html_script_element_execute())
-
- count_total_html_element_recorder.collect_value(count_total_html_elements)
- count_document_html_element_recorder.collect_value(
- count_document_html_elements)
- count_layout_box_recorder.collect_value(count_layout_boxes)
- count_render_trees_recorder.collect_value(count_render_trees_end -
- count_render_trees_start)
- count_requested_images_recorder.collect_value(count_requested_images)
-
- duration_navigate_to_on_load_recorder.collect_value(
- on_load_event_time - navigate_time)
- duration_navigate_to_browse_recorder.collect_value(
- browse_time - navigate_time)
- duration_navigate_to_usable_recorder.collect_value(
- usable_time - navigate_time)
-
- # Record the counts
- count_total_html_element_recorder.on_end_test()
- count_document_html_element_recorder.on_end_test()
- count_layout_box_recorder.on_end_test()
- count_render_trees_recorder.on_end_test()
- count_requested_images_recorder.on_end_test()
-
- # Record the durations
- tv_testcase_util.record_test_result(
- STARTUP_RECORD_NAME + "DurLaunchToNavigateUs",
- dur_launch_to_navigate_us)
- tv_testcase_util.record_test_result(
- STARTUP_RECORD_NAME + "DurLaunchToOnLoadUs",
- dur_launch_to_on_load_event_us)
- tv_testcase_util.record_test_result(
- STARTUP_RECORD_NAME + "DurLaunchToBrowseUs", dur_launch_to_browse_us)
- tv_testcase_util.record_test_result(
- STARTUP_RECORD_NAME + "DurLaunchToUsableUs", dur_launch_to_usable_us)
-
- duration_navigate_to_on_load_recorder.on_end_test()
- duration_navigate_to_browse_recorder.on_end_test()
- duration_navigate_to_usable_recorder.on_end_test()
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/video/__init__.py b/src/cobalt/webdriver_benchmarks/tests/performance/video/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/video/__init__.py
+++ /dev/null
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance/video/browse_to_watch.py b/src/cobalt/webdriver_benchmarks/tests/performance/video/browse_to_watch.py
deleted file mode 100755
index 248e73c..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance/video/browse_to_watch.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/python2
-"""Simple benchmark for starting a video from browse."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-
-# Add the base webdriver_benchmarks path
-sys.path.insert(0,
- os.path.dirname(
- os.path.dirname((os.path.dirname(
- os.path.dirname(os.path.realpath(__file__)))))))
-
-# pylint: disable=C6204,C6203
-import tv_testcase
-import tv_testcase_event_recorder
-import tv_testcase_util
-
-# selenium imports
-keys = tv_testcase_util.import_selenium_module("webdriver.common.keys")
-
-MAX_VIDEO_FAILURE_COUNT = 10
-MAX_SKIPPABLE_AD_COUNT = 8
-
-NUM_LOAD_TV_CALLS = 4
-NUM_ITERATIONS_PER_LOAD_TV_CALL = 25
-
-BROWSE_TO_WATCH_EVENT_NAME = "wbBrowseToWatch"
-BROWSE_TO_WATCH_EVENT_TYPE = tv_testcase_util.EVENT_TYPE_KEY_UP
-
-WATCH_TO_BROWSE_EVENT_NAME = "wbWatchToBrowse"
-WATCH_TO_BROWSE_EVENT_TYPE = tv_testcase_util.EVENT_TYPE_KEY_UP
-
-
-class BrowseToWatchTest(tv_testcase.TvTestCase):
-
- class VideoFailureException(BaseException):
- """Exception thrown when MAX_VIDEO_FAILURE_COUNT is exceeded."""
-
- class AdvertisementFailureException(BaseException):
- """Exception thrown when MAX_SKIPPABLE_AD_COUNT is exceeded."""
-
- def test_simple(self):
- recorder_options = tv_testcase_event_recorder.EventRecorderOptions(
- self, BROWSE_TO_WATCH_EVENT_NAME, BROWSE_TO_WATCH_EVENT_TYPE)
- recorder_options.record_animations = False
- recorder_options.record_video = True
- browse_to_watch_recorder = tv_testcase_event_recorder.EventRecorder(
- recorder_options)
-
- recorder_options = tv_testcase_event_recorder.EventRecorderOptions(
- self, WATCH_TO_BROWSE_EVENT_NAME, WATCH_TO_BROWSE_EVENT_TYPE)
- recorder_options.record_animations = False
- watch_to_browse_recorder = tv_testcase_event_recorder.EventRecorder(
- recorder_options)
-
- failure_count = 0
- skippable_ad_count = 0
-
- for _ in xrange(NUM_LOAD_TV_CALLS):
- self.load_tv()
-
- for _ in xrange(NUM_ITERATIONS_PER_LOAD_TV_CALL):
- self.send_keys(keys.Keys.ARROW_DOWN)
- self.wait_for_processing_complete_after_focused_shelf()
-
- browse_to_watch_recorder.on_start_event()
- self.send_keys(keys.Keys.ENTER)
-
- if not self.wait_for_media_element_playing():
- failure_count += 1
- print("Video failed to play! {} events failed.".format(failure_count))
- if failure_count > MAX_VIDEO_FAILURE_COUNT:
- raise BrowseToWatchTest.VideoFailureException()
-
- self.send_keys(keys.Keys.ESCAPE)
- self.wait_for_processing_complete_after_focused_shelf()
- continue
-
- if self.skip_advertisement_if_playing():
- skippable_ad_count += 1
- print(
- "Encountered skippable ad! {} total.".format(skippable_ad_count))
- if skippable_ad_count > MAX_SKIPPABLE_AD_COUNT:
- raise BrowseToWatchTest.AdvertisementFailureException()
-
- self.wait_for_title_card_hidden()
- self.send_keys(keys.Keys.ESCAPE)
- self.wait_for_processing_complete_after_focused_shelf()
- continue
-
- browse_to_watch_recorder.on_end_event()
-
- # Wait for the title card hidden before sending the escape. Otherwise,
- # two escapes are required to exit the video.
- self.wait_for_title_card_hidden()
-
- watch_to_browse_recorder.on_start_event()
- self.send_keys(keys.Keys.ESCAPE)
- self.wait_for_processing_complete_after_focused_shelf()
- watch_to_browse_recorder.on_end_event()
-
- browse_to_watch_recorder.on_end_test()
- watch_to_browse_recorder.on_end_test()
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance_non_video.py b/src/cobalt/webdriver_benchmarks/tests/performance_non_video.py
deleted file mode 100644
index f71a433..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance_non_video.py
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/usr/bin/python2
-"""Target for running non-video performance test cases."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import importlib
-import os
-import sys
-import unittest
-
-# The parent directory is a module
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
-
-# pylint: disable=C6204,C6203
-import tv_testcase
-
-
-def _add_test(test_suite, dir_path, test_name):
- if os.path.isfile(
- os.path.join(dir_path, "performance", "non_video", test_name + ".py")):
- print("Adding test: {}".format(test_name))
- test_suite.addTest(unittest.TestLoader().loadTestsFromModule(
- importlib.import_module("tests.performance.non_video." + test_name)))
-
-
-# pylint: disable=unused-argument
-def load_tests(loader, tests, pattern):
- """This is a Python unittest "load_tests protocol method."""
- test_suite = unittest.TestSuite()
- dir_path = os.path.dirname(__file__)
-
- # "startup" must be the first test added. The timings that it
- # records require it to run first.
- _add_test(test_suite, dir_path, "startup")
- _add_test(test_suite, dir_path, "browse_horizontal")
- _add_test(test_suite, dir_path, "browse_vertical")
- _add_test(test_suite, dir_path, "browse_to_guide")
- _add_test(test_suite, dir_path, "browse_to_search")
-
- return test_suite
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/performance_video.py b/src/cobalt/webdriver_benchmarks/tests/performance_video.py
deleted file mode 100755
index 3784cc2..0000000
--- a/src/cobalt/webdriver_benchmarks/tests/performance_video.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/python2
-"""Target for running video performance test cases."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import importlib
-import os
-import sys
-import unittest
-
-# The parent directory is a module
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
-
-# pylint: disable=C6204,C6203
-import tv_testcase
-
-
-def _add_test(test_suite, dir_path, test_name):
- if os.path.isfile(
- os.path.join(dir_path, "performance", "video", test_name + ".py")):
- print("Adding test: {}".format(test_name))
- test_suite.addTest(unittest.TestLoader().loadTestsFromModule(
- importlib.import_module("tests.performance.video." + test_name)))
-
-
-# pylint: disable=unused-argument
-def load_tests(loader, tests, pattern):
- """This is a Python unittest "load_tests protocol method."""
- test_suite = unittest.TestSuite()
- dir_path = os.path.dirname(__file__)
-
- _add_test(test_suite, dir_path, "browse_to_watch")
-
- return test_suite
-
-
-if __name__ == "__main__":
- tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tv.py b/src/cobalt/webdriver_benchmarks/tv.py
deleted file mode 100644
index 332b3c9..0000000
--- a/src/cobalt/webdriver_benchmarks/tv.py
+++ /dev/null
@@ -1,13 +0,0 @@
-"""CSS Constants."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-FOCUSED_GUIDE = '.focused.guide'
-FOCUSED_SEARCH = '.focused.search'
-FOCUSED_SHELF = '.focused.selected.shelf'
-FOCUSED_SHELF_TITLE = '.focused.selected.shelf .shelf-header-title .main'
-SKIP_AD_BUTTON_CAN_SKIP = '.skip-ad-button.canskip'
-SKIP_AD_BUTTON_HIDDEN = '.skip-ad-button.hidden'
-TITLE_CARD_HIDDEN = '.title-card.hidden'
diff --git a/src/cobalt/webdriver_benchmarks/tv_testcase.py b/src/cobalt/webdriver_benchmarks/tv_testcase.py
deleted file mode 100644
index dc49278..0000000
--- a/src/cobalt/webdriver_benchmarks/tv_testcase.py
+++ /dev/null
@@ -1,343 +0,0 @@
-"""Base class for WebDriver tests."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import json
-import logging
-import os
-import sys
-import time
-import unittest
-
-# This directory is a package
-sys.path.insert(0, os.path.abspath("."))
-# pylint: disable=C6204,C6203
-import c_val_names
-import tv
-import tv_testcase_runner
-import tv_testcase_util
-
-try:
- import custom_query_param_constants as query_param_constants
-except ImportError:
- import default_query_param_constants as query_param_constants
-
-# selenium imports
-# pylint: disable=C0103
-ActionChains = tv_testcase_util.import_selenium_module(
- submodule="webdriver.common.action_chains").ActionChains
-keys = tv_testcase_util.import_selenium_module("webdriver.common.keys")
-
-WINDOWDRIVER_CREATED_TIMEOUT_SECONDS = 30
-WEBMODULE_LOADED_TIMEOUT_SECONDS = 30
-PAGE_LOAD_WAIT_SECONDS = 30
-PROCESSING_TIMEOUT_SECONDS = 60
-HTML_SCRIPT_ELEMENT_EXECUTE_TIMEOUT_SECONDS = 30
-MEDIA_TIMEOUT_SECONDS = 30
-SKIP_AD_TIMEOUT_SECONDS = 30
-TITLE_CARD_HIDDEN_TIMEOUT_SECONDS = 30
-
-_is_initialized = False
-
-
-class TvTestCase(unittest.TestCase):
- """Base class for WebDriver tests.
-
- Style note: snake_case is used for function names here so as to match
- with an internal class with the same name.
- """
-
- class WindowDriverCreatedTimeoutException(BaseException):
- """Exception thrown when WindowDriver was not created in time."""
-
- class WebModuleLoadedTimeoutException(BaseException):
- """Exception thrown when WebModule was not loaded in time."""
-
- class ProcessingTimeoutException(BaseException):
- """Exception thrown when processing did not complete in time."""
-
- class HtmlScriptElementExecuteTimeoutException(BaseException):
- """Exception thrown when processing did not complete in time."""
-
- class TitleCardHiddenTimeoutException(BaseException):
- """Exception thrown when title card did not disappear in time."""
-
- @classmethod
- def setUpClass(cls):
- print("Running " + cls.__name__)
-
- @classmethod
- def tearDownClass(cls):
- print("Done " + cls.__name__)
-
- def setUp(self):
- global _is_initialized
- if not _is_initialized:
- # Initialize the tests.
- query_params = query_param_constants.INIT_QUERY_PARAMS
- triggers_reload = query_param_constants.INIT_QUERY_PARAMS_TRIGGER_RELOAD
- self.load_tv(query_params, triggers_reload)
- _is_initialized = True
-
- def get_webdriver(self):
- return tv_testcase_runner.GetWebDriver()
-
- def get_default_url(self):
- return tv_testcase_runner.GetDefaultUrl()
-
- def get_cval(self, cval_name):
- """Returns the Python object represented by a JSON cval string.
-
- Args:
- cval_name: Name of the cval.
- Returns:
- Python object represented by the JSON cval string
- """
- javascript_code = "return h5vcc.cVal.getValue('{}')".format(cval_name)
- json_result = self.get_webdriver().execute_script(javascript_code)
- if json_result is None:
- return None
- else:
- return json.loads(json_result)
-
- def load_blank(self):
- """Loads about:blank and waits for it to finish.
-
- Raises:
- Underlying WebDriver exceptions
- """
- self.clear_url_loaded_events()
- self.get_webdriver().get("about:blank")
- self.wait_for_url_loaded_events()
-
- def load_tv(self, query_params=None, triggers_reload=False):
- """Loads the main TV page and waits for it to display.
-
- Args:
- query_params: A dict containing additional query parameters.
- triggers_reload: Whether or not the navigation will trigger a reload.
- Raises:
- Underlying WebDriver exceptions
- """
- self.get_webdriver().execute_script("h5vcc.storage.clearCookies()")
- self.clear_url_loaded_events()
- self.get_webdriver().get(
- tv_testcase_util.generate_url(self.get_default_url(), query_params))
- self.wait_for_url_loaded_events()
- if triggers_reload:
- self.clear_url_loaded_events()
- self.wait_for_url_loaded_events()
- # Note that the internal tests use "expect_transition" which is
- # a mechanism that sets a maximum timeout for a "@with_retries"
- # decorator-driven success retry loop for subsequent webdriver requests.
- #
- # We'll skip that sophistication here.
- self.wait_for_processing_complete_after_focused_shelf()
-
- def poll_until_found(self, css_selector):
- """Polls until an element is found.
-
- Args:
- css_selector: A CSS selector
- Raises:
- Underlying WebDriver exceptions
- """
- start_time = time.time()
- while ((not self.find_elements(css_selector)) and
- (time.time() - start_time < PAGE_LOAD_WAIT_SECONDS)):
- time.sleep(1)
- self.assert_displayed(css_selector)
-
- def unique_find(self, unique_selector):
- """Finds and returns a uniquely selected element.
-
- Args:
- unique_selector: A CSS selector that will select only one element
- Raises:
- Underlying WebDriver exceptions
- AssertError: the element isn't unique
- Returns:
- Element
- """
- return self.find_elements(unique_selector, expected_num=1)[0]
-
- def assert_displayed(self, css_selector):
- """Asserts that an element is displayed.
-
- Args:
- css_selector: A CSS selector
- Raises:
- Underlying WebDriver exceptions
- AssertError: the element isn't found
- """
- # TODO does not actually assert that it's visible, like webdriver.py
- # probably does.
- self.assertTrue(self.unique_find(css_selector))
-
- def find_elements(self, css_selector, expected_num=None):
- """Finds elements based on a selector.
-
- Args:
- css_selector: A CSS selector
- expected_num: Expected number of matching elements
- Raises:
- Underlying WebDriver exceptions
- AssertError: expected_num isn't met
- Returns:
- Array of selected elements
- """
- elements = self.get_webdriver().find_elements_by_css_selector(css_selector)
- if expected_num is not None:
- self.assertEqual(len(elements), expected_num)
- return elements
-
- def send_keys(self, key_events):
- """Sends keys to whichever element currently has focus.
-
- Args:
- key_events: key events
-
- Raises:
- Underlying WebDriver exceptions
- """
- ActionChains(self.get_webdriver()).send_keys(key_events).perform()
-
- def clear_url_loaded_events(self):
- """Clear the events that indicate that Cobalt finished loading a URL."""
- tv_testcase_runner.GetWindowDriverCreated().clear()
- tv_testcase_runner.GetWebModuleLoaded().clear()
-
- def wait_for_url_loaded_events(self):
- """Wait for the events indicating that Cobalt finished loading a URL."""
- windowdriver_created = tv_testcase_runner.GetWindowDriverCreated()
- if not windowdriver_created.wait(WINDOWDRIVER_CREATED_TIMEOUT_SECONDS):
- raise TvTestCase.WindowDriverCreatedTimeoutException()
-
- webmodule_loaded = tv_testcase_runner.GetWebModuleLoaded()
- if not webmodule_loaded.wait(WEBMODULE_LOADED_TIMEOUT_SECONDS):
- raise TvTestCase.WebModuleLoadedTimeoutException()
-
- def wait_for_processing_complete_after_focused_shelf(self):
- """Waits for Cobalt to focus on a shelf and complete pending layouts."""
- self.poll_until_found(tv.FOCUSED_SHELF)
- self.assert_displayed(tv.FOCUSED_SHELF_TITLE)
- self.wait_for_processing_complete()
-
- def wait_for_processing_complete(self, check_animations=True):
- """Waits for Cobalt to complete processing.
-
- This method requires two consecutive iterations through its loop where
- Cobalt is not processing before treating processing as complete. This
- protects against a brief window between two different processing sections
- being mistaken as completed processing.
-
- Args:
- check_animations: Whether or not animations should be checked when
- determining if processing is complete.
-
- Raises:
- ProcessingTimeoutException: Processing is not complete within the
- required time.
- """
- start_time = time.time()
-
- # First simply check for whether or not the event is still processing.
- # There's no need to check anything else while the event is still going on.
- # Once it is done processing, it won't get re-set, so there's no need to
- # re-check it.
- while self.get_cval(c_val_names.event_is_processing()):
- if time.time() - start_time > PROCESSING_TIMEOUT_SECONDS:
- raise TvTestCase.ProcessingTimeoutException()
-
- time.sleep(0.1)
-
- # Now wait for all processing to complete in Cobalt.
- count = 0
- while count < 2:
- if self.is_processing(check_animations):
- count = 0
- else:
- count += 1
-
- if time.time() - start_time > PROCESSING_TIMEOUT_SECONDS:
- raise TvTestCase.ProcessingTimeoutException()
-
- time.sleep(0.1)
-
- def is_processing(self, check_animations):
- """Checks to see if Cobalt is currently processing."""
- return (self.get_cval(c_val_names.count_dom_active_java_script_events()) or
- self.get_cval(c_val_names.layout_is_dirty()) or
- (check_animations and
- self.get_cval(c_val_names.renderer_has_active_animations())) or
- self.get_cval(c_val_names.count_image_cache_loading_resources()))
-
- def wait_for_html_script_element_execute_count(self, required_count):
- """Waits for specified number of html script element Execute() calls.
-
- Args:
- required_count: the number of executions that must occur
-
- Raises:
- HtmlScriptElementExecuteTimeoutException: The required html script element
- executions did not occur within the required time.
- """
- start_time = time.time()
- while self.get_cval(
- c_val_names.count_dom_html_script_element_execute()) < required_count:
- if time.time() - start_time > HTML_SCRIPT_ELEMENT_EXECUTE_TIMEOUT_SECONDS:
- raise TvTestCase.HtmlScriptElementExecuteTimeoutException()
- time.sleep(0.1)
-
- def wait_for_media_element_playing(self):
- """Waits for a video to begin playing.
-
- Returns:
- Whether or not the video started.
- """
- start_time = time.time()
- while self.get_cval(
- c_val_names.event_duration_dom_video_start_delay()) == 0:
- if time.time() - start_time > MEDIA_TIMEOUT_SECONDS:
- return False
- time.sleep(0.1)
-
- return True
-
- def skip_advertisement_if_playing(self):
- """Waits to skip an ad if it is encountered.
-
- Returns:
- True if a skippable advertisement was encountered
- """
- start_time = time.time()
- if not self.find_elements(tv.SKIP_AD_BUTTON_HIDDEN):
- while not self.find_elements(tv.SKIP_AD_BUTTON_CAN_SKIP):
- if time.time() - start_time > SKIP_AD_TIMEOUT_SECONDS:
- return True
- time.sleep(0.1)
- self.send_keys(keys.Keys.ENTER)
- self.wait_for_processing_complete(False)
- return True
-
- return False
-
- def wait_for_title_card_hidden(self):
- """Waits for the title to disappear while a video is playing.
-
- Raises:
- TitleCardHiddenTimeoutException: The title card did not become hidden in
- the required time.
- """
- start_time = time.time()
- while not self.find_elements(tv.TITLE_CARD_HIDDEN):
- if time.time() - start_time > TITLE_CARD_HIDDEN_TIMEOUT_SECONDS:
- raise TvTestCase.TitleCardHiddenTimeoutException()
- time.sleep(1)
-
-
-def main():
- logging.basicConfig(level=logging.DEBUG)
- tv_testcase_runner.main()
diff --git a/src/cobalt/webdriver_benchmarks/tv_testcase_event_recorder.py b/src/cobalt/webdriver_benchmarks/tv_testcase_event_recorder.py
deleted file mode 100644
index 5905e84..0000000
--- a/src/cobalt/webdriver_benchmarks/tv_testcase_event_recorder.py
+++ /dev/null
@@ -1,262 +0,0 @@
-#!/usr/bin/python2
-"""Records stats on an event injected by a benchmark test."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import c_val_names
-import tv_testcase_util
-
-
-class EventRecorderOptions(object):
- """Contains all of the parameters needed by EventRecorder."""
-
- def __init__(self, test, event_name, event_type):
- """Initializes the event recorder options.
-
- Args:
- test: specific benchmark test being run
- event_name: name of the event being recorded
- event_type: type of event being recorded (tv_testcase_util.py)
- """
- self.test = test
- self.event_name = event_name
- self.event_type = event_type
-
- self.record_animations = True
- self.record_video = False
-
-
-class EventRecorder(object):
- """Records stats on an event injected by a benchmark test.
-
- Handles collecting event data over all of the instances of a specific event
- injected by a benchmark test and records statistics on the data when the test
- ends. The specific event types that can be injected are listed within
- tv_testcase_util.py.
-
- Both rasterize animations and video start delay data can potentially be
- recorded, depending on the |record_animations| and |record_video| option
- flags.
- """
-
- def __init__(self, options):
- """Initializes the event recorder.
-
- Handles setting up this event recorder, including creating all of its
- recorders, based upon the passed in options.
-
- Args:
- options: the settings to use in creating this event recorder
- """
- self.test = options.test
- self.event_name = options.event_name
- self.event_type = options.event_type
-
- self.render_tree_failure_count = 0
-
- # Each entry in the list contains a tuple with a key and value recorder.
- self.value_dictionary_recorders = []
-
- # Optional animations recorders
- self.animations_recorder = None
- self.animations_start_delay_recorder = None
- self.animations_end_delay_recorder = None
-
- # Optional video recorders
- self.video_delay_recorder = None
-
- # Count record strategies
- count_record_strategies = []
- count_record_strategies.append(tv_testcase_util.RecordStrategyMean())
- count_record_strategies.append(tv_testcase_util.RecordStrategyMedian())
- count_record_strategies.append(tv_testcase_util.RecordStrategyMax())
-
- # Duration record strategies
- duration_record_strategies = []
- duration_record_strategies.append(tv_testcase_util.RecordStrategyMean())
- duration_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(25))
- duration_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(50))
- duration_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(75))
- duration_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(95))
-
- # Video delay record strategies
- video_delay_record_strategies = []
- video_delay_record_strategies.append(tv_testcase_util.RecordStrategyMean())
- video_delay_record_strategies.append(tv_testcase_util.RecordStrategyMin())
- video_delay_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(25))
- video_delay_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(50))
- video_delay_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(75))
- video_delay_record_strategies.append(
- tv_testcase_util.RecordStrategyPercentile(95))
- video_delay_record_strategies.append(tv_testcase_util.RecordStrategyMax())
-
- # Dictionary count recorders
- self._add_value_dictionary_recorder("CntDomEventListeners",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntDomNodes", count_record_strategies)
- self._add_value_dictionary_recorder("CntDomHtmlElements",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntDomDocumentHtmlElements",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntDomHtmlElementsCreated",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntDomUpdateMatchingRules",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntDomUpdateComputedStyle",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntDomGenerateHtmlComputedStyle",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntDomGeneratePseudoComputedStyle",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntLayoutBoxes",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntLayoutBoxesCreated",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntLayoutUpdateSize",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntLayoutRenderAndAnimate",
- count_record_strategies)
- self._add_value_dictionary_recorder("CntLayoutUpdateCrossReferences",
- count_record_strategies)
-
- # Dictionary duration recorders
- self._add_value_dictionary_recorder("DurTotalUs",
- duration_record_strategies)
- self._add_value_dictionary_recorder("DurDomInjectEventUs",
- duration_record_strategies)
- self._add_value_dictionary_recorder("DurDomRunAnimationFrameCallbacksUs",
- duration_record_strategies)
- self._add_value_dictionary_recorder("DurDomUpdateComputedStyleUs",
- duration_record_strategies)
- self._add_value_dictionary_recorder("DurLayoutBoxTreeUs",
- duration_record_strategies)
- self._add_value_dictionary_recorder("DurLayoutBoxTreeBoxGenerationUs",
- duration_record_strategies)
- self._add_value_dictionary_recorder("DurLayoutBoxTreeUpdateUsedSizesUs",
- duration_record_strategies)
- self._add_value_dictionary_recorder("DurLayoutRenderAndAnimateUs",
- duration_record_strategies)
-
- self.count_render_trees_recorder = tv_testcase_util.ResultsRecorder(
- self.event_name + "CntRenderTrees", count_record_strategies)
- self.count_requested_images_recorder = tv_testcase_util.ResultsRecorder(
- self.event_name + "CntRequestedImages", count_record_strategies)
-
- # Optional animations recorder
- if options.record_animations:
- self.animations_recorder = tv_testcase_util.ResultsRecorder(
- self.event_name + "DurRasterizeAnimationsUs",
- duration_record_strategies)
- self.animations_start_delay_recorder = tv_testcase_util.ResultsRecorder(
- self.event_name + "DurAnimationsStartDelayUs",
- duration_record_strategies)
- self.animations_end_delay_recorder = tv_testcase_util.ResultsRecorder(
- self.event_name + "DurAnimationsEndDelayUs",
- duration_record_strategies)
-
- self.final_render_tree_delay_recorder = tv_testcase_util.ResultsRecorder(
- self.event_name + "DurFinalRenderTreeDelayUs",
- duration_record_strategies)
-
- # Optional video recorder
- if options.record_video:
- self.video_delay_recorder = tv_testcase_util.ResultsRecorder(
- self.event_name + "DurVideoStartDelayUs",
- video_delay_record_strategies)
-
- def _add_value_dictionary_recorder(self, key, record_strategies):
- recorder = tv_testcase_util.ResultsRecorder(self.event_name + key,
- record_strategies)
- self.value_dictionary_recorders.append((key, recorder))
-
- def on_start_event(self):
- """Handles logic related to the start of the event instance."""
- self.count_render_trees_start = self.test.get_cval(
- c_val_names.count_rasterize_new_render_tree())
- self.count_requested_images_start = self.test.get_cval(
- c_val_names.count_image_cache_requested_resources())
-
- def on_end_event(self):
- """Handles logic related to the end of the event instance."""
-
- value_dictionary = self.test.get_cval(
- c_val_names.event_value_dictionary(self.event_type))
-
- # If the event failed to produce a render tree, then its data is not
- # collected. Log the failure and return.
- if not value_dictionary or not value_dictionary.get("ProducedRenderTree"):
- self.render_tree_failure_count += 1
- print("{} event failed to produce render tree! {} events failed.".format(
- self.event_name, self.render_tree_failure_count))
- return
-
- event_start_time = value_dictionary.get("StartTime")
-
- # Record all of the values from the event.
- for value_dictionary_recorder in self.value_dictionary_recorders:
- value = value_dictionary.get(value_dictionary_recorder[0])
- if value is not None:
- value_dictionary_recorder[1].collect_value(value)
-
- self.count_render_trees_end = self.test.get_cval(
- c_val_names.count_rasterize_new_render_tree())
- self.count_render_trees_recorder.collect_value(
- self.count_render_trees_end - self.count_render_trees_start)
-
- self.count_requested_images_end = self.test.get_cval(
- c_val_names.count_image_cache_requested_resources())
- self.count_requested_images_recorder.collect_value(
- self.count_requested_images_end - self.count_requested_images_start)
-
- if self.animations_recorder:
- animation_entries = self.test.get_cval(
- c_val_names.rasterize_animations_entry_list())
- for value in animation_entries:
- self.animations_recorder.collect_value(value)
-
- animations_start_time = self.test.get_cval(
- c_val_names.time_rasterize_animations_start())
- self.animations_start_delay_recorder.collect_value(
- animations_start_time - event_start_time)
- animations_end_time = self.test.get_cval(
- c_val_names.time_rasterize_animations_end())
- self.animations_end_delay_recorder.collect_value(animations_end_time -
- event_start_time)
-
- final_render_tree_time = self.test.get_cval(
- c_val_names.time_rasterize_new_render_tree())
- self.final_render_tree_delay_recorder.collect_value(final_render_tree_time -
- event_start_time)
-
- if self.video_delay_recorder:
- self.video_delay_recorder.collect_value(
- self.test.get_cval(
- c_val_names.event_duration_dom_video_start_delay()))
-
- def on_end_test(self):
- """Handles logic related to the end of the test."""
-
- for value_dictionary_recorder in self.value_dictionary_recorders:
- value_dictionary_recorder[1].on_end_test()
-
- self.count_render_trees_recorder.on_end_test()
- self.count_requested_images_recorder.on_end_test()
-
- if self.animations_recorder:
- self.animations_recorder.on_end_test()
- self.animations_start_delay_recorder.on_end_test()
- self.animations_end_delay_recorder.on_end_test()
-
- self.final_render_tree_delay_recorder.on_end_test()
-
- if self.video_delay_recorder:
- self.video_delay_recorder.on_end_test()
diff --git a/src/cobalt/webdriver_benchmarks/tv_testcase_runner.py b/src/cobalt/webdriver_benchmarks/tv_testcase_runner.py
deleted file mode 100755
index 45c8556..0000000
--- a/src/cobalt/webdriver_benchmarks/tv_testcase_runner.py
+++ /dev/null
@@ -1,297 +0,0 @@
-#!/usr/bin/python2
-"""Runs webdriver-based Cobalt benchmark tests."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import argparse
-import importlib
-import inspect
-import os
-import re
-import sys
-import thread
-import threading
-import unittest
-
-import tv_testcase_util
-
-arg_parser = argparse.ArgumentParser(
- description="Runs Webdriver-based Cobalt benchmark tests")
-arg_parser.add_argument(
- "-p",
- "--platform",
- help="Cobalt platform, eg 'linux-x64x11'."
- "Fetched from environment if absent.")
-arg_parser.add_argument(
- "-e",
- "--executable",
- help="Path to Cobalt executable. "
- "Auto-derived if absent.")
-arg_parser.add_argument(
- "-c",
- "--config",
- choices=["debug", "devel", "qa", "gold"],
- help="Build config (eg, 'qa' or 'devel'). Not used if "
- "--executable is specified. Fetched from environment "
- "if needed and absent.")
-arg_parser.add_argument(
- "-d",
- "--devkit_name",
- help="Devkit or IP address for app_launcher."
- "Current hostname used if absent.")
-arg_parser.add_argument(
- "--command_line",
- nargs="*",
- help="Command line arguments to pass to the Cobalt executable.")
-arg_parser.add_argument(
- "--url", help="Specifies the URL to run the tests against.")
-arg_parser.add_argument(
- "-o", "--log_file", help="Logfile pathname. stdout if absent.")
-
-# Pattern to match Cobalt log line for when the WebDriver port has been
-# opened.
-RE_WEBDRIVER_LISTEN = re.compile(r"Starting WebDriver server on port (\d+)")
-# Pattern to match Cobalt log line for when a WindowDriver has been created.
-RE_WINDOWDRIVER_CREATED = re.compile(
- r"^\[\d+/\d+:INFO:browser_module\.cc\(\d+\)\] Created WindowDriver: ID=\S+")
-# Pattern to match Cobalt log line for when a WebModule is has been loaded.
-RE_WEBMODULE_LOADED = re.compile(
- r"^\[\d+/\d+:INFO:browser_module\.cc\(\d+\)\] Loaded WebModule")
-
-DEFAULT_STARTUP_TIMEOUT_SECONDS = 2 * 60
-WEBDRIVER_HTTP_TIMEOUT_SECONDS = 2 * 60
-COBALT_EXIT_TIMEOUT_SECONDS = 5
-
-COBALT_WEBDRIVER_CAPABILITIES = {
- "browserName": "cobalt",
- "javascriptEnabled": True,
- "platform": "LINUX"
-}
-
-_webdriver = None
-_windowdriver_created = threading.Event()
-_webmodule_loaded = threading.Event()
-_default_url = "https://www.youtube.com/tv"
-
-
-def GetWebDriver():
- """Returns the active connect WebDriver instance."""
- return _webdriver
-
-
-def GetWindowDriverCreated():
- """Returns the WindowDriver created instance."""
- return _windowdriver_created
-
-
-def GetWebModuleLoaded():
- """Returns the WebModule loaded instance."""
- return _webmodule_loaded
-
-
-def GetDefaultUrl():
- """Returns the default url to use with tests."""
- return _default_url
-
-
-class TimeoutException(Exception):
- pass
-
-
-class CobaltRunner(object):
- """Runs a Cobalt browser w/ a WebDriver client attached."""
- test_script_started = threading.Event()
- selenium_webdriver_module = None
- webdriver = None
- launcher = None
- log_file_path = None
- thread = None
- failed = False
- should_exit = threading.Event()
-
- def __init__(self, platform, executable, devkit_name, command_line_args,
- default_url, log_file_path):
- global _default_url
- if default_url is not None:
- _default_url = default_url
-
- self.selenium_webdriver_module = tv_testcase_util.import_selenium_module(
- "webdriver")
-
- script_path = os.path.realpath(inspect.getsourcefile(lambda: 0))
- app_launcher_path = os.path.realpath(
- os.path.join(
- os.path.dirname(script_path), "..", "..", "tools", "lbshell"))
- sys.path.append(app_launcher_path)
- app_launcher = importlib.import_module("app_launcher")
- self.launcher = app_launcher.CreateLauncher(
- platform, executable, devkit_name=devkit_name, close_output_file=False)
-
- args = []
- if command_line_args is not None:
- for command_line_arg in command_line_args:
- args.append("--" + command_line_arg)
- args.append("--enable_webdriver")
- args.append("--debug_console=off")
- args.append("--disable_image_animations")
- args.append("--null_savegame")
- args.append("--url=" + _default_url)
-
- self.launcher.SetArgs(args)
- self.launcher.SetOutputCallback(self._HandleLine)
- self.log_file_path = log_file_path
- self.log_file = None
-
- def __enter__(self):
- self.thread = threading.Thread(target=self.Run)
- self.thread.start()
- try:
- self.WaitForStart()
- except KeyboardInterrupt:
- # potentially from thread.interrupt_main(). We will treat as
- # a timeout regardless
- self.SetShouldExit(failed=True)
- raise TimeoutException
- return self
-
- def __exit__(self, exc_type, exc_value, traceback):
- # The unittest module terminates with a SystemExit
- # If this is a successful exit, then this is a successful run
- success = exc_type is None or (exc_type is SystemExit and
- not exc_value.code)
- self.SetShouldExit(failed=not success)
- self.thread.join(COBALT_EXIT_TIMEOUT_SECONDS)
-
- def _HandleLine(self, line):
- """Internal log line callback."""
-
- if RE_WINDOWDRIVER_CREATED.search(line):
- _windowdriver_created.set()
- return
-
- if RE_WEBMODULE_LOADED.search(line):
- _webmodule_loaded.set()
- return
-
- # Wait for WebDriver port here then connect
- if self.test_script_started.is_set():
- return
-
- match = RE_WEBDRIVER_LISTEN.search(line)
- if not match:
- return
-
- port = match.group(1)
- print("WebDriver port opened:" + port + "\n", file=self.log_file)
- self._StartWebdriver(port)
-
- def SetShouldExit(self, failed=False):
- """Indicates cobalt process should exit."""
- self.failed = failed
- self.should_exit.set()
- self.launcher.SendKill()
-
- def _GetProcessIPAddress(self):
- return self.launcher.GetProcessIPAddress()
-
- def _StartWebdriver(self, port):
- global _webdriver
- url = "http://{}:{}/".format(self._GetProcessIPAddress(), port)
- self.webdriver = self.selenium_webdriver_module.Remote(
- url, COBALT_WEBDRIVER_CAPABILITIES)
- self.webdriver.command_executor.set_timeout(WEBDRIVER_HTTP_TIMEOUT_SECONDS)
- print("Selenium Connected\n", file=self.log_file)
- _webdriver = self.webdriver
- self.test_script_started.set()
-
- def WaitForStart(self):
- """Waits for the webdriver client to attach to Cobalt."""
- startup_timeout_seconds = self.launcher.GetStartupTimeout()
- if not startup_timeout_seconds:
- startup_timeout_seconds = DEFAULT_STARTUP_TIMEOUT_SECONDS
-
- if not self.test_script_started.wait(startup_timeout_seconds):
- self.SetShouldExit(failed=True)
- raise TimeoutException
- print("Cobalt started", file=self.log_file)
-
- def Run(self):
- """Thread run routine."""
-
- # Use stdout if log_file_path is unspecified
- # If log_file_path is specified, make sure to close it
- to_close = None
- try:
- if self.log_file_path:
- self.log_file = open(self.log_file_path, "w")
- to_close = self.log_file
- else:
- self.log_file = sys.stdout
-
- self.launcher.SetOutputFile(self.log_file)
- print("Running launcher", file=self.log_file)
- self.launcher.Run()
- print(
- "Cobalt terminated. failed: " + str(self.failed), file=self.log_file)
- # This is watched for in webdriver_benchmark_test.py
- if not self.failed:
- print("{}\n".format(tv_testcase_util.TEST_COMPLETE))
- # pylint: disable=broad-except
- except Exception as ex:
- print("Exception running Cobalt " + str(ex), file=sys.stderr)
- finally:
- if to_close:
- to_close.close()
- if not self.should_exit.is_set():
- # If the main thread is not expecting us to exit,
- # we must interrupt it.
- thread.interrupt_main()
- return 0
-
-
-def GetCobaltExecutablePath(platform, config):
- """Auto-derives a path to a cobalt executable."""
- if config is None:
- try:
- config = os.environ["BUILD_TYPE"]
- except KeyError:
- sys.stderr.write("Must specify --config or --executable\n")
- sys.exit(1)
- script_path = os.path.realpath(inspect.getsourcefile(lambda: 0))
- script_dir = os.path.dirname(script_path)
- out_dir = os.path.join(script_dir, "..", "..", "out")
- executable_directory = os.path.join(out_dir, "{}_{}".format(platform, config))
- return os.path.join(executable_directory, "cobalt")
-
-
-def main():
- args = arg_parser.parse_args()
- # Keep unittest module from seeing these args
- sys.argv = sys.argv[:1]
-
- platform = args.platform
- if platform is None:
- try:
- platform = os.environ["BUILD_PLATFORM"]
- except KeyError:
- sys.stderr.write("Must specify --platform\n")
- sys.exit(1)
-
- executable = args.executable
- if executable is None:
- executable = GetCobaltExecutablePath(platform, args.config)
-
- try:
- with CobaltRunner(platform, executable, args.devkit_name, args.command_line,
- args.url, args.log_file) as runner:
- unittest.main(testRunner=unittest.TextTestRunner(
- verbosity=0, stream=runner.log_file))
- except TimeoutException:
- print("Timeout waiting for Cobalt to start", file=sys.stderr)
- sys.exit(1)
-
-
-if __name__ == "__main__":
- main()
diff --git a/src/cobalt/webdriver_benchmarks/tv_testcase_util.py b/src/cobalt/webdriver_benchmarks/tv_testcase_util.py
deleted file mode 100644
index 6cb9a52..0000000
--- a/src/cobalt/webdriver_benchmarks/tv_testcase_util.py
+++ /dev/null
@@ -1,200 +0,0 @@
-"""Provides constants and functions needed by tv_testcase classes."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import importlib
-import json
-import sys
-
-# pylint: disable=C6204
-from urllib import urlencode
-import urlparse
-
-import container_util
-
-try:
- import custom_query_param_constants as query_param_constants
-except ImportError:
- import default_query_param_constants as query_param_constants
-
-# These are watched for in webdriver_benchmark_test.py
-TEST_RESULT = "webdriver_benchmark TEST RESULT"
-TEST_COMPLETE = "webdriver_benchmark TEST COMPLETE"
-
-# These are event types that can be injected
-EVENT_TYPE_KEY_DOWN = "KeyDown"
-EVENT_TYPE_KEY_UP = "KeyUp"
-
-
-def import_selenium_module(submodule=None):
- """Dynamically imports a selenium.webdriver submodule.
-
- This is done because selenium 3.0 is not commonly pre-installed
- on workstations, and we want to have a friendly error message for that
- case.
-
- Args:
- submodule: module subpath underneath "selenium.webdriver"
- Returns:
- appropriate module
- """
- if submodule:
- module_path = ".".join(("selenium", submodule))
- else:
- module_path = "selenium"
- # As of this writing, Google uses selenium 3.0.0b2 internally, so
- # thats what we will target here as well.
- try:
- module = importlib.import_module(module_path)
- if submodule is None:
- # Only the top-level module has __version__
- if not module.__version__.startswith("3.0"):
- raise ImportError("Not version 3.0.x")
- except ImportError:
- sys.stderr.write("Could not import {}\n"
- "Please install selenium >= 3.0.0b2.\n"
- "Commonly: \"sudo pip install 'selenium>=3.0.0b2'\"\n"
- .format(module_path))
- sys.exit(1)
- return module
-
-
-def generate_url(default_url, query_params_override=None):
- """Returns the URL indicated by the path and query parameters.
-
- Args:
- default_url: the default url to use; its query params may be overridden
- query_params_override: optional query params that override the ones
- contained within the default URL
- Returns:
- the url generated from the parameters
- """
- parsed_url = list(urlparse.urlparse(default_url))
-
- query_params = query_param_constants.BASE_QUERY_PARAMS
- if query_params_override:
- query_params.update(query_params_override)
- else:
- query_params.update(urlparse.parse_qsl(parsed_url[4]))
-
- parsed_url[4] = urlencode(query_params, doseq=True)
- return urlparse.urlunparse(parsed_url)
-
-
-def record_test_result(name, result):
- """Records an individual scalar result of a benchmark test.
-
- Args:
- name: string name of test case
- result: Test result. Must be JSON encodable scalar.
- """
- value_to_record = result
-
- string_value_to_record = json.JSONEncoder().encode(value_to_record)
- print("{}: {} {}\n".format(TEST_RESULT, name, string_value_to_record))
- sys.stdout.flush()
-
-
-class RecordStrategyMax(object):
- """"Records the max of an array of values."""
-
- def run(self, name, values):
- """Records the max of an array of values.
-
- Args:
- name: string name of test case
- values: must be array of JSON encodable scalar
- """
- record_test_result("{}Max".format(name), max(values))
-
-
-class RecordStrategyMin(object):
- """"Records the min of an array of values."""
-
- def run(self, name, values):
- """Records the min of an array of values.
-
- Args:
- name: string name of test case
- values: must be array of JSON encodable scalar
- """
- record_test_result("{}Min".format(name), min(values))
-
-
-class RecordStrategyMean(object):
- """"Records the mean of an array of values."""
-
- def run(self, name, values):
- """Records the mean of an array of values.
-
- Args:
- name: string name of test case
- values: must be array of JSON encodable scalar
- """
- record_test_result("{}Mean".format(name), container_util.mean(values))
-
-
-class RecordStrategyMedian(object):
- """"Records the median of an array of test results."""
-
- def run(self, name, values):
- """Records the median of an array of values.
-
- Args:
- name: string name of test case
- values: must be array of JSON encodable scalar
- """
- record_test_result("{}Median".format(name),
- container_util.percentile(values, 50))
-
-
-class RecordStrategyPercentile(object):
- """"Records the specified percentile of an array of test results."""
-
- def __init__(self, percentile):
- """Initializes the record strategy.
-
- Args:
- percentile: the percentile to record
- """
- self.percentile = percentile
-
- def run(self, name, values):
- """Records the percentile of an array of values.
-
- Args:
- name: string name of test case
- values: must be array of JSON encodable scalar
- Raises:
- RuntimeError: Raised on invalid args.
- """
- record_test_result("{}Pct{}".format(name, self.percentile),
- container_util.percentile(values, self.percentile))
-
-
-class ResultsRecorder(object):
- """"Collects values and records results after a benchmark test ends."""
-
- def __init__(self, name, record_strategies):
- """Initializes the value recorder.
-
- Args:
- name: the name to use when recording test results
- record_strategies: the strategies to use when the test ends
- """
- self.name = name
- self.record_strategies = record_strategies
- self.values = []
-
- def collect_value(self, value):
- self.values.append(value)
-
- def on_end_test(self):
- """Handles logic related to the end of the benchmark test."""
-
- # Only run the strategies if values have been collected.
- if self.values:
- for record_strategy in self.record_strategies:
- record_strategy.run(self.name, self.values)
diff --git a/src/net/url_request/url_request_job_manager.cc b/src/net/url_request/url_request_job_manager.cc
index 1ab6814..ed0f5db 100644
--- a/src/net/url_request/url_request_job_manager.cc
+++ b/src/net/url_request/url_request_job_manager.cc
@@ -39,9 +39,7 @@
static const SchemeToFactory kBuiltinFactories[] = {
{"https", URLRequestHttpJob::Factory},
{"data", URLRequestDataJob::Factory},
-#if !defined(COBALT_FORCE_HTTPS)
{ "http", URLRequestHttpJob::Factory },
-#endif
#if defined(COBALT_ENABLE_FILE_SCHEME)
{ "file", URLRequestFileJob::Factory },
#endif
diff --git a/src/starboard/client_porting/eztime/eztime.cc b/src/starboard/client_porting/eztime/eztime.cc
index 10c86f4..aa4f737 100644
--- a/src/starboard/client_porting/eztime/eztime.cc
+++ b/src/starboard/client_porting/eztime/eztime.cc
@@ -115,8 +115,17 @@
SB_DCHECK(value);
SB_DCHECK(out_exploded);
UErrorCode status = U_ZERO_ERROR;
+
+ // Always query the time using a gregorian calendar. This is
+ // implied in opengroup documentation for tm struct, even though it is not
+ // specified. E.g. in gmtime's documentation, it states that UTC time is
+ // used, and in tm struct's documentation it is specified that year should
+ // be an offset from 1900.
+
+ // See:
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/gmtime.html
UCalendar* calendar = ucal_open(GetTimeZoneId(timezone), -1,
- uloc_getDefault(), UCAL_DEFAULT, &status);
+ uloc_getDefault(), UCAL_GREGORIAN, &status);
if (!calendar) {
return false;
}
@@ -157,8 +166,17 @@
EzTimeZone timezone) {
SB_DCHECK(exploded);
UErrorCode status = U_ZERO_ERROR;
+
+ // Always query the time using a gregorian calendar. This is
+ // implied in opengroup documentation for tm struct, even though it is not
+ // specified. E.g. in gmtime's documentation, it states that UTC time is
+ // used, and in tm struct's documentation it is specified that year should
+ // be an offset from 1900.
+
+ // See:
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/gmtime.html
UCalendar* calendar = ucal_open(GetTimeZoneId(timezone), -1,
- uloc_getDefault(), UCAL_DEFAULT, &status);
+ uloc_getDefault(), UCAL_GREGORIAN, &status);
if (!calendar) {
EzTimeValue zero_time = {};
return zero_time;
diff --git a/src/starboard/shared/starboard/media/media_can_play_mime_and_key_system.cc b/src/starboard/shared/starboard/media/media_can_play_mime_and_key_system.cc
index 0a96110..bdf679d 100644
--- a/src/starboard/shared/starboard/media/media_can_play_mime_and_key_system.cc
+++ b/src/starboard/shared/starboard/media/media_can_play_mime_and_key_system.cc
@@ -257,6 +257,14 @@
}
}
+ std::string cryptoblockformat =
+ mime_type.GetParamStringValue("cryptoblockformat", "");
+ if (!cryptoblockformat.empty()) {
+ if (mime_type.subtype() != "webm" || cryptoblockformat != "subsample") {
+ return kSbMediaSupportTypeNotSupported;
+ }
+ }
+
int width = 0;
int height = 0;
int fps = 0;
