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;
