Import Cobalt 4.13110
diff --git a/src/cobalt/browser/web_module.cc b/src/cobalt/browser/web_module.cc
index 5ee42a0..29a4b1d 100644
--- a/src/cobalt/browser/web_module.cc
+++ b/src/cobalt/browser/web_module.cc
@@ -615,9 +615,6 @@
// Stop the generation of render trees.
layout_manager_->Suspend();
- // Clear out all image resources from the image cache.
- image_cache_->Purge();
-
#if defined(ENABLE_DEBUG_CONSOLE)
// The debug overlay may be holding onto a render tree, clear that out.
debug_overlay_->ClearInput();
@@ -627,6 +624,17 @@
// in-progress loads.
loader_factory_->Suspend();
+ // Ensure the document is not holding onto any more image cached resources so
+ // that they are eligible to be purged.
+ window_->document()->PurgeCachedResourceReferencesRecursively();
+
+ // Clear out all image resources from the image cache. We need to do this
+ // after we abort all in-progress loads, and after we clear all document
+ // references, or they will still be referenced and won't be cleared from the
+ // cache.
+ image_cache_->Purge();
+ remote_typeface_cache_->Purge();
+
// Finally mark that we have no resource provider.
resource_provider_ = NULL;
}
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index ec9b96f..d5688f5 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-13031
\ No newline at end of file
+13110
\ No newline at end of file
diff --git a/src/cobalt/dom/html_element.h b/src/cobalt/dom/html_element.h
index 33ffb9a..4aad8a2 100644
--- a/src/cobalt/dom/html_element.h
+++ b/src/cobalt/dom/html_element.h
@@ -261,6 +261,10 @@
void CopyDirectionality(const HTMLElement& other);
+ // Releases image resources and invalidates computed style if there are images
+ // associated with this html element in the image cache.
+ void ReleaseImagesAndInvalidateComputedStyleIfNecessary() OVERRIDE;
+
private:
// From Node.
void OnMutation() OVERRIDE;
@@ -289,10 +293,6 @@
// https://www.w3.org/TR/html5/semantics.html#the-root-element.
bool IsRootElement();
- // Releases image resources and invalidates computed style if there are images
- // associated with this html element in the image cache.
- void ReleaseImagesAndInvalidateComputedStyleIfNecessary();
-
// The directionality of the html element is determined by the 'dir'
// attribute.
// https://dev.w3.org/html5/spec-preview/global-attributes.html#the-directionality
diff --git a/src/cobalt/dom/node.cc b/src/cobalt/dom/node.cc
index 6ce2955..cac03aa 100644
--- a/src/cobalt/dom/node.cc
+++ b/src/cobalt/dom/node.cc
@@ -467,6 +467,16 @@
}
}
+void Node::PurgeCachedResourceReferencesRecursively() {
+ ReleaseImagesAndInvalidateComputedStyleIfNecessary();
+
+ Node* child = first_child_;
+ while (child) {
+ child->PurgeCachedResourceReferencesRecursively();
+ child = child->next_sibling_;
+ }
+}
+
void Node::InvalidateLayoutBoxesFromNodeAndAncestors() {
if (parent_) {
parent_->InvalidateLayoutBoxesFromNodeAndAncestors();
diff --git a/src/cobalt/dom/node.h b/src/cobalt/dom/node.h
index 0c2a4f6..7e349d6 100644
--- a/src/cobalt/dom/node.h
+++ b/src/cobalt/dom/node.h
@@ -218,6 +218,10 @@
virtual scoped_refptr<Node> Duplicate() const = 0;
+ // Purges all cached resource reference from the current node and all
+ // descendents.
+ void PurgeCachedResourceReferencesRecursively();
+
DEFINE_WRAPPABLE_TYPE(Node);
protected:
@@ -244,6 +248,10 @@
// Invalidate the render tree nodes within the layout boxes of this node.
virtual void InvalidateRenderTreeNodesFromNode() {}
+ // Releases image resources and invalidates computed style if there are images
+ // associated with this html element in the image cache.
+ virtual void ReleaseImagesAndInvalidateComputedStyleIfNecessary() {}
+
// Triggers a generation update in this node and all its ancestor nodes.
void UpdateGenerationForNodeAndAncestors();
diff --git a/src/cobalt/dom_parser/html_decoder.h b/src/cobalt/dom_parser/html_decoder.h
index db142e7..cf57cf9 100644
--- a/src/cobalt/dom_parser/html_decoder.h
+++ b/src/cobalt/dom_parser/html_decoder.h
@@ -20,6 +20,7 @@
#include <string>
#include "base/callback.h"
+#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/threading/thread_checker.h"
@@ -60,6 +61,11 @@
const scoped_refptr<net::HttpResponseHeaders>& headers) OVERRIDE;
void DecodeChunk(const char* data, size_t size) OVERRIDE;
void Finish() OVERRIDE;
+ bool Suspend() OVERRIDE { return false; }
+
+ void Resume(render_tree::ResourceProvider* /*resource_provider*/) OVERRIDE {
+ NOTIMPLEMENTED();
+ };
private:
// This subclass is responsible for providing the handlers for the interface
diff --git a/src/cobalt/dom_parser/xml_decoder.h b/src/cobalt/dom_parser/xml_decoder.h
index 1be11a7..2ee38e4 100644
--- a/src/cobalt/dom_parser/xml_decoder.h
+++ b/src/cobalt/dom_parser/xml_decoder.h
@@ -52,6 +52,11 @@
// From Decoder.
void DecodeChunk(const char* data, size_t size) OVERRIDE;
void Finish() OVERRIDE;
+ bool Suspend() OVERRIDE { return false; }
+
+ void Resume(render_tree::ResourceProvider* /*resource_provider*/) OVERRIDE {
+ NOTIMPLEMENTED();
+ };
private:
// This subclass is responsible for providing the handlers for the interface
diff --git a/src/cobalt/loader/decoder.h b/src/cobalt/loader/decoder.h
index f307097..bdd4040 100644
--- a/src/cobalt/loader/decoder.h
+++ b/src/cobalt/loader/decoder.h
@@ -18,6 +18,7 @@
#define COBALT_LOADER_DECODER_H_
#include "cobalt/loader/loader_types.h"
+#include "cobalt/render_tree/resource_provider.h"
#include "net/http/http_response_headers.h"
namespace cobalt {
@@ -45,7 +46,13 @@
// This is called when all data are sent in and decoding should be finalized.
virtual void Finish() = 0;
- virtual void Abort() { NOTREACHED() << "Abort not supported."; }
+ // Suspends the decode of this resource, resetting internal state. Returns
+ // whether the decoder was reset correctly. If not, the load will have to be
+ // aborted.
+ virtual bool Suspend() = 0;
+
+ // Resumes the decode of this resource, starting over from the zero state.
+ virtual void Resume(render_tree::ResourceProvider* resource_provider) = 0;
};
} // namespace loader
diff --git a/src/cobalt/loader/fetcher_factory.cc b/src/cobalt/loader/fetcher_factory.cc
index 81b7d2f..e16c970 100644
--- a/src/cobalt/loader/fetcher_factory.cc
+++ b/src/cobalt/loader/fetcher_factory.cc
@@ -44,6 +44,16 @@
*file_path = FilePath(path);
return !file_path->empty();
}
+
+std::string ClipUrl(const GURL& url, size_t length) {
+ const std::string& spec = url.possibly_invalid_spec();
+ if (spec.size() < length) {
+ return spec;
+ }
+
+ return spec.substr(0, length - 5) + "[...]";
+}
+
} // namespace
FetcherFactory::FetcherFactory(network::NetworkModule* network_module)
@@ -72,6 +82,7 @@
return scoped_ptr<Fetcher>(NULL);
}
+ DLOG(INFO) << "Fetching: " << ClipUrl(url, 60);
scoped_ptr<Fetcher> fetcher;
if (url.SchemeIs(kEmbeddedScheme)) {
EmbeddedFetcher::Options options;
diff --git a/src/cobalt/loader/font/typeface_decoder.cc b/src/cobalt/loader/font/typeface_decoder.cc
index 2f7556d..9d2e6db 100644
--- a/src/cobalt/loader/font/typeface_decoder.cc
+++ b/src/cobalt/loader/font/typeface_decoder.cc
@@ -29,7 +29,7 @@
success_callback_(success_callback),
error_callback_(error_callback),
is_raw_data_too_large_(false),
- aborted_(false) {
+ suspended_(false) {
UNREFERENCED_PARAMETER(failure_callback);
DCHECK(resource_provider_);
@@ -38,6 +38,11 @@
}
void TypefaceDecoder::DecodeChunk(const char* data, size_t size) {
+ if (suspended_) {
+ DLOG(WARNING) << __FUNCTION__ << "[" << this << "] while suspended.";
+ return;
+ }
+
// If the data was already too large, then there's no need to process this
// chunk. Just early out.
if (is_raw_data_too_large_) {
@@ -65,16 +70,16 @@
}
void TypefaceDecoder::Finish() {
+ if (suspended_) {
+ DLOG(WARNING) << __FUNCTION__ << "[" << this << "] while suspended.";
+ return;
+ }
+
if (is_raw_data_too_large_) {
error_callback_.Run("Raw typeface data size too large");
return;
}
- if (aborted_) {
- error_callback_.Run(
- "TypefaceDecoder's ResourceProvider has been externally aborted.");
- return;
- }
if (!resource_provider_) {
error_callback_.Run(
"No resource provider was passed to the TypefaceDecoder.");
@@ -95,7 +100,24 @@
void TypefaceDecoder::ReleaseRawData() { raw_data_.reset(); }
-void TypefaceDecoder::Abort() { aborted_ = true; }
+bool TypefaceDecoder::Suspend() {
+ DCHECK(!suspended_);
+ suspended_ = true;
+ is_raw_data_too_large_ = false;
+ resource_provider_ = NULL;
+ ReleaseRawData();
+ return true;
+}
+
+void TypefaceDecoder::Resume(render_tree::ResourceProvider* resource_provider) {
+ if (!suspended_) {
+ DCHECK_EQ(resource_provider_, resource_provider);
+ return;
+ }
+
+ suspended_ = false;
+ resource_provider_ = resource_provider;
+}
} // namespace font
} // namespace loader
diff --git a/src/cobalt/loader/font/typeface_decoder.h b/src/cobalt/loader/font/typeface_decoder.h
index 4af8965..83ed308 100644
--- a/src/cobalt/loader/font/typeface_decoder.h
+++ b/src/cobalt/loader/font/typeface_decoder.h
@@ -47,20 +47,20 @@
// From Decoder.
void DecodeChunk(const char* data, size_t size) OVERRIDE;
void Finish() OVERRIDE;
-
- void Abort() OVERRIDE;
+ bool Suspend() OVERRIDE;
+ void Resume(render_tree::ResourceProvider* resource_provider) OVERRIDE;
private:
void ReleaseRawData();
- render_tree::ResourceProvider* const resource_provider_;
+ render_tree::ResourceProvider* resource_provider_;
const SuccessCallback success_callback_;
const ErrorCallback error_callback_;
scoped_ptr<render_tree::ResourceProvider::RawTypefaceDataVector> raw_data_;
bool is_raw_data_too_large_;
- bool aborted_;
+ bool suspended_;
};
} // namespace font
diff --git a/src/cobalt/loader/font/typeface_decoder_test.cc b/src/cobalt/loader/font/typeface_decoder_test.cc
index 9b767d6..4d12892 100644
--- a/src/cobalt/loader/font/typeface_decoder_test.cc
+++ b/src/cobalt/loader/font/typeface_decoder_test.cc
@@ -54,6 +54,8 @@
void DecodeChunk(const char* data, size_t size) OVERRIDE;
void Finish() OVERRIDE;
+ bool Suspend() OVERRIDE;
+ void Resume(render_tree::ResourceProvider* resource_provider) OVERRIDE;
scoped_refptr<render_tree::Typeface> Typeface();
@@ -83,6 +85,13 @@
void MockTypefaceDecoder::Finish() { typeface_decoder_->Finish(); }
+bool MockTypefaceDecoder::Suspend() { return typeface_decoder_->Suspend(); }
+
+void MockTypefaceDecoder::Resume(
+ render_tree::ResourceProvider* resource_provider) {
+ typeface_decoder_->Resume(resource_provider);
+}
+
scoped_refptr<render_tree::Typeface> MockTypefaceDecoder::Typeface() {
return typeface_decoder_callback_.typeface;
}
diff --git a/src/cobalt/loader/image/image_decoder.cc b/src/cobalt/loader/image/image_decoder.cc
index 24a8f9b..5161dd3 100644
--- a/src/cobalt/loader/image/image_decoder.cc
+++ b/src/cobalt/loader/image/image_decoder.cc
@@ -71,6 +71,11 @@
Fetcher* fetcher, const scoped_refptr<net::HttpResponseHeaders>& headers) {
UNREFERENCED_PARAMETER(fetcher);
+ if (state_ == kSuspended) {
+ DLOG(WARNING) << __FUNCTION__ << "[" << this << "] while suspended.";
+ return kLoadResponseContinue;
+ }
+
if (headers->response_code() == net::HTTP_OK &&
headers->GetContentLength() == 0) {
// The server successfully processed the request and expected some contents,
@@ -137,8 +142,8 @@
case kNoResourceProvider:
failure_callback_.Run("No resource provider was passed to the decoder.");
break;
- case kAborted:
- error_callback_.Run("ImageDecoder received an external signal to abort.");
+ case kSuspended:
+ DLOG(WARNING) << __FUNCTION__ << "[" << this << "] while suspended.";
break;
case kNotApplicable:
// no image is available.
@@ -147,13 +152,28 @@
}
}
-void ImageDecoder::Abort() {
+bool ImageDecoder::Suspend() {
if (state_ == kDecoding) {
DCHECK(decoder_);
decoder_.reset();
- state_ = kAborted;
- } else if (state_ == kWaitingForHeader) {
- state_ = kAborted;
+ }
+ state_ = kSuspended;
+ signature_cache_.position = 0;
+ resource_provider_ = NULL;
+ return true;
+}
+
+void ImageDecoder::Resume(render_tree::ResourceProvider* resource_provider) {
+ if (state_ != kSuspended) {
+ DCHECK_EQ(resource_provider_, resource_provider);
+ return;
+ }
+
+ state_ = kWaitingForHeader;
+ resource_provider_ = resource_provider;
+
+ if (!resource_provider_) {
+ state_ = kNoResourceProvider;
}
}
@@ -182,7 +202,7 @@
} break;
case kNotApplicable:
case kUnsupportedImageFormat:
- case kAborted:
+ case kSuspended:
case kNoResourceProvider:
default: {
// Do not attempt to continue processing data.
diff --git a/src/cobalt/loader/image/image_decoder.h b/src/cobalt/loader/image/image_decoder.h
index be6e056..610d27b 100644
--- a/src/cobalt/loader/image/image_decoder.h
+++ b/src/cobalt/loader/image/image_decoder.h
@@ -52,8 +52,8 @@
const scoped_refptr<net::HttpResponseHeaders>& headers) OVERRIDE;
void DecodeChunk(const char* data, size_t size) OVERRIDE;
void Finish() OVERRIDE;
-
- void Abort() OVERRIDE;
+ bool Suspend() OVERRIDE;
+ void Resume(render_tree::ResourceProvider* resource_provider) OVERRIDE;
// Call this function to use the StubImageDecoder which produces a small image
// without decoding.
@@ -66,7 +66,7 @@
kNotApplicable,
kUnsupportedImageFormat,
kNoResourceProvider,
- kAborted,
+ kSuspended,
};
// The current longest signature is WEBP signature.
@@ -81,7 +81,7 @@
bool InitializeInternalDecoder(const uint8* input_bytes, size_t size,
size_t* consumed_size);
- render_tree::ResourceProvider* const resource_provider_;
+ render_tree::ResourceProvider* resource_provider_;
const SuccessCallback success_callback_;
const FailureCallback failure_callback_;
const ErrorCallback error_callback_;
diff --git a/src/cobalt/loader/image/image_decoder_test.cc b/src/cobalt/loader/image/image_decoder_test.cc
index 59c1d38..dafc54b 100644
--- a/src/cobalt/loader/image/image_decoder_test.cc
+++ b/src/cobalt/loader/image/image_decoder_test.cc
@@ -58,6 +58,8 @@
void DecodeChunk(const char* data, size_t size) OVERRIDE;
void Finish() OVERRIDE;
+ bool Suspend() OVERRIDE;
+ void Resume(render_tree::ResourceProvider* resource_provider) OVERRIDE;
scoped_refptr<render_tree::Image> Image();
@@ -92,6 +94,13 @@
void MockImageDecoder::Finish() { image_decoder_->Finish(); }
+bool MockImageDecoder::Suspend() { return image_decoder_->Suspend(); }
+
+void MockImageDecoder::Resume(
+ render_tree::ResourceProvider* resource_provider) {
+ image_decoder_->Resume(resource_provider);
+}
+
scoped_refptr<render_tree::Image> MockImageDecoder::Image() {
return image_decoder_callback_.image;
}
diff --git a/src/cobalt/loader/loader.cc b/src/cobalt/loader/loader.cc
index 90e6bfe..a5d86e7 100644
--- a/src/cobalt/loader/loader.cc
+++ b/src/cobalt/loader/loader.cc
@@ -70,23 +70,23 @@
//////////////////////////////////////////////////////////////////
Loader::Loader(const FetcherCreator& fetcher_creator,
- scoped_ptr<Decoder> decoder,
- const base::Callback<void(const std::string&)>& error_callback,
+ scoped_ptr<Decoder> decoder, const OnErrorFunction& on_error,
const OnDestructionFunction& on_destruction)
- : decoder_(decoder.Pass()),
- fetcher_to_decoder_adaptor_(
- new FetcherToDecoderAdapter(decoder_.get(), error_callback)),
- fetcher_(fetcher_creator.Run(fetcher_to_decoder_adaptor_.get())),
- on_destruction_(on_destruction) {
+ : fetcher_creator_(fetcher_creator),
+ decoder_(decoder.Pass()),
+ on_error_(on_error),
+ on_destruction_(on_destruction),
+ suspended_(false) {
DCHECK(decoder_);
- DCHECK(!error_callback.is_null());
- DCHECK(!fetcher_creator.is_null());
+ DCHECK(!on_error.is_null());
+
+ Start();
// Post the error callback on the current message loop in case loader is
// destroyed in the callback.
if (!fetcher_) {
fetcher_creator_error_closure_.Reset(
- base::Bind(error_callback, "Fetcher was not created."));
+ base::Bind(on_error, "Fetcher was not created."));
MessageLoop::current()->PostTask(FROM_HERE,
fetcher_creator_error_closure_.callback());
}
@@ -101,7 +101,44 @@
fetcher_creator_error_closure_.Cancel();
}
-void Loader::Abort() { decoder_->Abort(); }
+void Loader::Suspend() {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ if (suspended_) {
+ return;
+ }
+
+ bool suspendable = decoder_->Suspend();
+ if (fetcher_) {
+ fetcher_.reset();
+ }
+
+ fetcher_to_decoder_adaptor_.reset();
+ fetcher_creator_error_closure_.Cancel();
+ suspended_ = true;
+
+ if (!suspendable) {
+ on_error_.Run("Aborted.");
+ }
+}
+
+void Loader::Resume(render_tree::ResourceProvider* resource_provider) {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ if (!suspended_) {
+ return;
+ }
+ suspended_ = false;
+ decoder_->Resume(resource_provider);
+ Start();
+}
+
+void Loader::Start() {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK(decoder_);
+ DCHECK(!fetcher_creator_.is_null());
+ fetcher_to_decoder_adaptor_.reset(
+ new FetcherToDecoderAdapter(decoder_.get(), on_error_));
+ fetcher_ = fetcher_creator_.Run(fetcher_to_decoder_adaptor_.get());
+}
} // namespace loader
} // namespace cobalt
diff --git a/src/cobalt/loader/loader.h b/src/cobalt/loader/loader.h
index 43da425..1a1bd1e 100644
--- a/src/cobalt/loader/loader.h
+++ b/src/cobalt/loader/loader.h
@@ -26,6 +26,7 @@
#include "base/threading/thread_checker.h"
#include "cobalt/loader/decoder.h"
#include "cobalt/loader/fetcher.h"
+#include "cobalt/render_tree/resource_provider.h"
namespace cobalt {
namespace loader {
@@ -38,6 +39,7 @@
public:
typedef base::Callback<scoped_ptr<Fetcher>(Fetcher::Handler*)> FetcherCreator;
typedef base::Callback<void(Loader*)> OnDestructionFunction;
+ typedef base::Callback<void(const std::string&)> OnErrorFunction;
// The construction of Loader initiates the loading. It takes the ownership
// of a Decoder and creates and manages a Fetcher using the given creation
@@ -45,16 +47,26 @@
// The fetcher creator, decoder and error callback shouldn't be NULL.
// It is allowed to destroy the loader in the error callback.
Loader(const FetcherCreator& fetcher_creator, scoped_ptr<Decoder> decoder,
- const base::Callback<void(const std::string&)>& error_callback,
+ const OnErrorFunction& on_error,
const OnDestructionFunction& on_destruction = OnDestructionFunction());
~Loader();
- void Abort();
+ // Suspends the load of this resource, expecting it to be resumed or destroyed
+ // later.
+ void Suspend();
+
+ // Resumes the load of this resource. Suspend must have been previously
+ // called.
+ void Resume(render_tree::ResourceProvider* resource_provider);
private:
class FetcherToDecoderAdapter;
+ // Starts the fetch-and-decode.
+ void Start();
+
+ FetcherCreator fetcher_creator_;
scoped_ptr<Decoder> decoder_;
scoped_ptr<FetcherToDecoderAdapter> fetcher_to_decoder_adaptor_;
scoped_ptr<Fetcher> fetcher_;
@@ -62,8 +74,11 @@
base::CancelableClosure fetcher_creator_error_closure_;
base::ThreadChecker thread_checker_;
+ OnErrorFunction on_error_;
OnDestructionFunction on_destruction_;
+ bool suspended_;
+
DISALLOW_COPY_AND_ASSIGN(Loader);
};
diff --git a/src/cobalt/loader/loader_factory.cc b/src/cobalt/loader/loader_factory.cc
index 9356c00..e39a512 100644
--- a/src/cobalt/loader/loader_factory.cc
+++ b/src/cobalt/loader/loader_factory.cc
@@ -76,7 +76,7 @@
resource_provider_ = NULL;
for (LoaderSet::const_iterator iter = active_loaders_.begin();
iter != active_loaders_.end(); ++iter) {
- (*iter)->Abort();
+ (*iter)->Suspend();
}
}
@@ -86,6 +86,10 @@
DCHECK(!resource_provider_);
resource_provider_ = resource_provider;
+ for (LoaderSet::const_iterator iter = active_loaders_.begin();
+ iter != active_loaders_.end(); ++iter) {
+ (*iter)->Resume(resource_provider);
+ }
}
void LoaderFactory::OnLoaderCreated(Loader* loader) {
diff --git a/src/cobalt/loader/loader_test.cc b/src/cobalt/loader/loader_test.cc
index f3be464..c7e637c 100644
--- a/src/cobalt/loader/loader_test.cc
+++ b/src/cobalt/loader/loader_test.cc
@@ -73,33 +73,47 @@
// Mocks & Stubs
//////////////////////////////////////////////////////////////////////////
-class StubFetcherError : public Fetcher {
- public:
- explicit StubFetcherError(Handler* handler) : Fetcher(handler) {
- handler->OnError(this, "Fake error for test");
- }
-
- static scoped_ptr<Fetcher> Create(Handler* handler) {
- return scoped_ptr<Fetcher>(new StubFetcherError(handler));
- }
-};
-
-class StubFetcherReceivedDone : public Fetcher {
- public:
- explicit StubFetcherReceivedDone(Handler* handler) : Fetcher(handler) {
- handler->OnReceived(this, NULL, 0);
- handler->OnDone(this);
- }
-
- static scoped_ptr<Fetcher> Create(Handler* handler) {
- return scoped_ptr<Fetcher>(new StubFetcherReceivedDone(handler));
- }
-};
-
class MockDecoder : public Decoder {
public:
MOCK_METHOD2(DecodeChunk, void(const char*, size_t));
MOCK_METHOD0(Finish, void());
+ MOCK_METHOD0(Suspend, bool());
+ MOCK_METHOD1(Resume, void(render_tree::ResourceProvider*));
+};
+
+class MockFetcher : public Fetcher {
+ public:
+ explicit MockFetcher(Handler* handler) : Fetcher(handler) {}
+
+ void FireError(const char* message) { handler()->OnError(this, message); }
+
+ void FireReceived(const char* data, size_t size) {
+ handler()->OnReceived(this, data, size);
+ }
+
+ void FireDone() { handler()->OnDone(this); }
+
+ static scoped_ptr<Fetcher> Create(Handler* handler) {
+ return scoped_ptr<Fetcher>(new MockFetcher(handler));
+ }
+};
+
+struct MockFetcherFactory {
+ public:
+ MockFetcherFactory(): count(0) {}
+ // Way to access the last fetcher created by the fetcher factory.
+ MockFetcher* fetcher;
+ int count;
+
+ scoped_ptr<Fetcher> Create(Fetcher::Handler* handler) {
+ fetcher = new MockFetcher(handler);
+ ++count;
+ return scoped_ptr<Fetcher>(fetcher);
+ }
+
+ Loader::FetcherCreator GetFetcherCreator() {
+ return base::Bind(&MockFetcherFactory::Create, base::Unretained(this));
+ }
};
class MockLoaderCallback : public LoaderCallback {
@@ -138,30 +152,77 @@
TEST_F(LoaderTest, FetcherError) {
MockLoaderCallback mock_loader_callback;
+ MockFetcherFactory mock_fetcher_factory;
MockDecoder* mock_decoder = new MockDecoder(); // To be owned by loader.
EXPECT_CALL(*mock_decoder, DecodeChunk(_, _)).Times(0);
EXPECT_CALL(*mock_decoder, Finish()).Times(0);
EXPECT_CALL(mock_loader_callback, OnError(_));
- Loader loader(base::Bind(&StubFetcherError::Create),
+ Loader loader(mock_fetcher_factory.GetFetcherCreator(),
scoped_ptr<Decoder>(mock_decoder),
base::Bind(&MockLoaderCallback::OnError,
base::Unretained(&mock_loader_callback)));
+ mock_fetcher_factory.fetcher->FireError("Fail");
+}
+
+TEST_F(LoaderTest, FetcherSuspendAbort) {
+ MockLoaderCallback mock_loader_callback;
+ MockFetcherFactory mock_fetcher_factory;
+ MockDecoder* mock_decoder = new MockDecoder(); // To be owned by loader.
+ EXPECT_CALL(*mock_decoder, DecodeChunk(_, _)).Times(0);
+ EXPECT_CALL(*mock_decoder, Finish()).Times(0);
+ EXPECT_CALL(*mock_decoder, Suspend());
+ EXPECT_CALL(*mock_decoder, Resume(_)).Times(0);
+ EXPECT_CALL(mock_loader_callback, OnError(_));
+
+ Loader loader(mock_fetcher_factory.GetFetcherCreator(),
+ scoped_ptr<Decoder>(mock_decoder),
+ base::Bind(&MockLoaderCallback::OnError,
+ base::Unretained(&mock_loader_callback)));
+ loader.Suspend();
+}
+
+TEST_F(LoaderTest, FetcherSuspendResumeDone) {
+ MockLoaderCallback mock_loader_callback;
+ MockFetcherFactory mock_fetcher_factory;
+ MockDecoder* mock_decoder = new MockDecoder(); // To be owned by loader.
+ ON_CALL(*mock_decoder, Suspend()).WillByDefault(testing::Return(true));
+
+ EXPECT_CALL(*mock_decoder, Suspend());
+ EXPECT_CALL(*mock_decoder, Resume(_));
+
+ EXPECT_CALL(*mock_decoder, DecodeChunk(_, _)).Times(0);
+ EXPECT_CALL(mock_loader_callback, OnError(_)).Times(0);
+ EXPECT_CALL(*mock_decoder, Finish());
+
+ Loader loader(mock_fetcher_factory.GetFetcherCreator(),
+ scoped_ptr<Decoder>(mock_decoder),
+ base::Bind(&MockLoaderCallback::OnError,
+ base::Unretained(&mock_loader_callback)));
+ loader.Suspend();
+ loader.Resume(NULL);
+
+ // The fetcher should have been torn down and recreated.
+ EXPECT_EQ(2, mock_fetcher_factory.count);
+ mock_fetcher_factory.fetcher->FireDone();
}
TEST_F(LoaderTest, FetcherReceiveDone) {
InSequence dummy;
MockLoaderCallback mock_loader_callback;
+ MockFetcherFactory mock_fetcher_factory;
MockDecoder* mock_decoder = new MockDecoder(); // To be owned by loader.
EXPECT_CALL(mock_loader_callback, OnError(_)).Times(0);
EXPECT_CALL(*mock_decoder, DecodeChunk(_, _));
EXPECT_CALL(*mock_decoder, Finish());
- Loader loader(base::Bind(&StubFetcherReceivedDone::Create),
+ Loader loader(mock_fetcher_factory.GetFetcherCreator(),
scoped_ptr<Decoder>(mock_decoder),
base::Bind(&MockLoaderCallback::OnError,
base::Unretained(&mock_loader_callback)));
+ mock_fetcher_factory.fetcher->FireReceived(NULL, 0);
+ mock_fetcher_factory.fetcher->FireDone();
}
// Typical usage of Loader.
diff --git a/src/cobalt/loader/text_decoder.h b/src/cobalt/loader/text_decoder.h
index 3c7cf13..5de3c4c 100644
--- a/src/cobalt/loader/text_decoder.h
+++ b/src/cobalt/loader/text_decoder.h
@@ -33,7 +33,7 @@
class TextDecoder : public Decoder {
public:
explicit TextDecoder(base::Callback<void(const std::string&)> done_callback)
- : done_callback_(done_callback) {}
+ : done_callback_(done_callback), suspended_(false) {}
~TextDecoder() OVERRIDE {}
// This function is used for binding callback for creating TextDecoder.
@@ -45,17 +45,32 @@
// From Decoder.
void DecodeChunk(const char* data, size_t size) OVERRIDE {
DCHECK(thread_checker_.CalledOnValidThread());
+ if (suspended_) {
+ return;
+ }
text_.append(data, size);
}
void Finish() OVERRIDE {
DCHECK(thread_checker_.CalledOnValidThread());
+ if (suspended_) {
+ return;
+ }
done_callback_.Run(text_);
}
+ bool Suspend() OVERRIDE {
+ suspended_ = true;
+ text_.clear();
+ return true;
+ }
+ void Resume(render_tree::ResourceProvider* /*resource_provider*/) OVERRIDE {
+ suspended_ = false;
+ }
private:
base::ThreadChecker thread_checker_;
std::string text_;
base::Callback<void(const std::string&)> done_callback_;
+ bool suspended_;
};
} // namespace loader
diff --git a/src/cobalt/script/mozjs/mozjs_engine.cc b/src/cobalt/script/mozjs/mozjs_engine.cc
index d5076b8..a2870e8 100644
--- a/src/cobalt/script/mozjs/mozjs_engine.cc
+++ b/src/cobalt/script/mozjs/mozjs_engine.cc
@@ -87,6 +87,17 @@
"Total JavaScript engine registered.") {
}
+// Pretend we always preserve wrappers since we never call
+// SetPreserveWrapperCallback anywhere else. This is necessary for
+// TryPreserveReflector called by WeakMap to not crash. Disabling
+// bindings to WeakMap does not appear to be an easy option because
+// of its use in selfhosted.js. See bugzilla discussion linked where
+// they decided to include a similar dummy in the mozjs shell.
+// https://bugzilla.mozilla.org/show_bug.cgi?id=829798
+bool DummyPreserveWrapperCallback(JSContext *cx, JSObject *obj) {
+ return true;
+}
+
} // namespace
MozjsEngine::MozjsEngine() {
@@ -124,6 +135,8 @@
// Callback to be called during garbage collection during the sweep phase.
JS_SetFinalizeCallback(runtime_, &MozjsEngine::FinalizeCallback);
+ js::SetPreserveWrapperCallback(runtime_, DummyPreserveWrapperCallback);
+
EngineStats::GetInstance()->EngineCreated();
}
diff --git a/src/cobalt/speech/audio_encoder_flac.cc b/src/cobalt/speech/audio_encoder_flac.cc
index d4403e1..16c5640 100644
--- a/src/cobalt/speech/audio_encoder_flac.cc
+++ b/src/cobalt/speech/audio_encoder_flac.cc
@@ -57,16 +57,21 @@
FLAC__stream_encoder_delete(encoder_);
}
-void AudioEncoderFlac::Encode(const AudioBus* audio_bus) {
+void AudioEncoderFlac::Encode(const ShellAudioBus* audio_bus) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK_EQ(audio_bus->channels(), 1);
- const float* audio_data = audio_bus->channel(0);
uint32 frames = static_cast<uint32>(audio_bus->frames());
scoped_array<FLAC__int32> flac_samples(new FLAC__int32[frames]);
for (uint32 i = 0; i < frames; ++i) {
- flac_samples[i] =
- static_cast<FLAC__int32>(audio_data[i] * kMaxInt16AsFloat32);
+ if (audio_bus->sample_type() == ShellAudioBus::kFloat32) {
+ flac_samples[i] = static_cast<FLAC__int32>(
+ audio_bus->GetFloat32Sample(0, i) * kMaxInt16AsFloat32);
+ } else {
+ DCHECK_EQ(audio_bus->sample_type(), ShellAudioBus::kInt16);
+ flac_samples[i] =
+ static_cast<FLAC__int32>(audio_bus->GetInt16Sample(0, i));
+ }
}
FLAC__int32* flac_samples_ptr = flac_samples.get();
diff --git a/src/cobalt/speech/audio_encoder_flac.h b/src/cobalt/speech/audio_encoder_flac.h
index be993ca..62fcfb1 100644
--- a/src/cobalt/speech/audio_encoder_flac.h
+++ b/src/cobalt/speech/audio_encoder_flac.h
@@ -22,7 +22,7 @@
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/threading/thread_checker.h"
-#include "media/base/audio_bus.h"
+#include "media/base/shell_audio_bus.h"
#include "third_party/flac/include/FLAC/stream_encoder.h"
namespace cobalt {
@@ -31,13 +31,13 @@
// Encode raw audio to using FLAC codec.
class AudioEncoderFlac {
public:
- typedef ::media::AudioBus AudioBus;
+ typedef ::media::ShellAudioBus ShellAudioBus;
explicit AudioEncoderFlac(int sample_rate);
~AudioEncoderFlac();
// Encode raw audio data.
- void Encode(const AudioBus* audio_bus);
+ void Encode(const ShellAudioBus* audio_bus);
// Finish encoding.
void Finish();
diff --git a/src/cobalt/speech/mic.h b/src/cobalt/speech/mic.h
index b83b875..506632a 100644
--- a/src/cobalt/speech/mic.h
+++ b/src/cobalt/speech/mic.h
@@ -20,7 +20,7 @@
#include <string>
#include "base/callback.h"
-#include "media/base/audio_bus.h"
+#include "media/base/shell_audio_bus.h"
namespace cobalt {
namespace speech {
@@ -28,8 +28,8 @@
// An abstract class is used for interacting platform specific microphone.
class Mic {
public:
- typedef ::media::AudioBus AudioBus;
- typedef base::Callback<void(scoped_ptr<AudioBus>)> DataReceivedCallback;
+ typedef ::media::ShellAudioBus ShellAudioBus;
+ typedef base::Callback<void(scoped_ptr<ShellAudioBus>)> DataReceivedCallback;
typedef base::Callback<void(void)> CompletionCallback;
typedef base::Callback<void(void)> ErrorCallback;
diff --git a/src/cobalt/speech/speech_recognition_manager.cc b/src/cobalt/speech/speech_recognition_manager.cc
index 2c69fc2..e531a77 100644
--- a/src/cobalt/speech/speech_recognition_manager.cc
+++ b/src/cobalt/speech/speech_recognition_manager.cc
@@ -93,7 +93,8 @@
state_ = kAborted;
}
-void SpeechRecognitionManager::OnDataReceived(scoped_ptr<AudioBus> audio_bus) {
+void SpeechRecognitionManager::OnDataReceived(
+ scoped_ptr<ShellAudioBus> audio_bus) {
if (!main_message_loop_->BelongsToCurrentThread()) {
// Called from mic thread.
main_message_loop_->PostTask(
@@ -123,9 +124,9 @@
// silence at the end in case encoder had no data already.
size_t dummy_frames =
static_cast<size_t>(kSampleRate * kAudioPacketDurationInSeconds);
- scoped_ptr<AudioBus> dummy_audio_bus =
- AudioBus::Create(1, static_cast<int>(dummy_frames));
- memset(dummy_audio_bus->channel(0), 0, dummy_frames);
+ scoped_ptr<ShellAudioBus> dummy_audio_bus(new ShellAudioBus(
+ 1, dummy_frames, ShellAudioBus::kInt16, ShellAudioBus::kPlanar));
+ dummy_audio_bus->ZeroAllFrames();
recognizer_.RecognizeAudio(dummy_audio_bus.Pass(), true);
}
}
diff --git a/src/cobalt/speech/speech_recognition_manager.h b/src/cobalt/speech/speech_recognition_manager.h
index dcc9457..852ede2 100644
--- a/src/cobalt/speech/speech_recognition_manager.h
+++ b/src/cobalt/speech/speech_recognition_manager.h
@@ -26,6 +26,7 @@
#include "cobalt/speech/speech_recognition_error.h"
#include "cobalt/speech/speech_recognition_event.h"
#include "cobalt/speech/speech_recognizer.h"
+#include "media/base/shell_audio_bus.h"
namespace cobalt {
namespace speech {
@@ -37,7 +38,7 @@
// class would encode the audio data, then send it to recogniton service.
class SpeechRecognitionManager {
public:
- typedef ::media::AudioBus AudioBus;
+ typedef ::media::ShellAudioBus ShellAudioBus;
typedef base::Callback<bool(const scoped_refptr<dom::Event>&)> EventCallback;
SpeechRecognitionManager(network::NetworkModule* network_module,
@@ -59,7 +60,7 @@
};
// Callbacks from mic.
- void OnDataReceived(scoped_ptr<AudioBus> audio_bus);
+ void OnDataReceived(scoped_ptr<ShellAudioBus> audio_bus);
void OnDataCompletion();
void OnMicError();
diff --git a/src/cobalt/speech/speech_recognizer.cc b/src/cobalt/speech/speech_recognizer.cc
index bdd0688..d5c1ce1 100644
--- a/src/cobalt/speech/speech_recognizer.cc
+++ b/src/cobalt/speech/speech_recognizer.cc
@@ -169,7 +169,7 @@
base::Bind(&SpeechRecognizer::StopInternal, base::Unretained(this)));
}
-void SpeechRecognizer::RecognizeAudio(scoped_ptr<AudioBus> audio_bus,
+void SpeechRecognizer::RecognizeAudio(scoped_ptr<ShellAudioBus> audio_bus,
bool is_last_chunk) {
// Called by the speech recognition manager thread.
thread_.message_loop()->PostTask(
@@ -293,8 +293,8 @@
chunked_byte_buffer_.Clear();
}
-void SpeechRecognizer::UploadAudioDataInternal(scoped_ptr<AudioBus> audio_bus,
- bool is_last_chunk) {
+void SpeechRecognizer::UploadAudioDataInternal(
+ scoped_ptr<ShellAudioBus> audio_bus, bool is_last_chunk) {
DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
DCHECK(audio_bus);
diff --git a/src/cobalt/speech/speech_recognizer.h b/src/cobalt/speech/speech_recognizer.h
index cb76a05..90e5dcd 100644
--- a/src/cobalt/speech/speech_recognizer.h
+++ b/src/cobalt/speech/speech_recognizer.h
@@ -42,7 +42,7 @@
// manager.
class SpeechRecognizer : public net::URLFetcherDelegate {
public:
- typedef ::media::AudioBus AudioBus;
+ typedef ::media::ShellAudioBus ShellAudioBus;
typedef base::Callback<void(const scoped_refptr<dom::Event>&)> EventCallback;
typedef SpeechRecognitionResultList::SpeechRecognitionResults
SpeechRecognitionResults;
@@ -58,7 +58,7 @@
// Stop speech recognizer.
void Stop();
// An encoded audio data is available and ready to be recognized.
- void RecognizeAudio(scoped_ptr<AudioBus> audio_bus, bool is_last_chunk);
+ void RecognizeAudio(scoped_ptr<ShellAudioBus> audio_bus, bool is_last_chunk);
// net::URLFetcherDelegate interface
void OnURLFetchDownloadData(const net::URLFetcher* source,
@@ -71,7 +71,7 @@
private:
void StartInternal(const SpeechRecognitionConfig& config, int sample_rate);
void StopInternal();
- void UploadAudioDataInternal(scoped_ptr<AudioBus> audio_bus,
+ void UploadAudioDataInternal(scoped_ptr<ShellAudioBus> audio_bus,
bool is_last_chunk);
void ProcessAndFireSuccessEvent(const SpeechRecognitionResults& new_results);
diff --git a/src/cobalt/webdriver_benchmarks/partial_layout_benchmark.py b/src/cobalt/webdriver_benchmarks/partial_layout_benchmark.py
index 41503c6..479ad5c 100755
--- a/src/cobalt/webdriver_benchmarks/partial_layout_benchmark.py
+++ b/src/cobalt/webdriver_benchmarks/partial_layout_benchmark.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python2
"""Webdriver-based benchmarks for partial layout.
Benchmarks for partial layout changes in Cobalt.
@@ -108,11 +108,12 @@
sys.path.append(script_path + "/../../tools/lbshell/")
app_launcher = importlib.import_module("app_launcher")
self.launcher = app_launcher.CreateLauncher(
- platform, executable, devkit_name=devkit_name)
+ platform, executable, devkit_name=devkit_name, close_output_file=False)
self.launcher.SetArgs(["--enable_webdriver"])
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)
@@ -166,13 +167,15 @@
to_close = None
try:
if self.log_file_path:
- log_file = open(self.log_file_path, "w")
- to_close = log_file
+ self.log_file = open(self.log_file_path, "w")
+ to_close = self.log_file
else:
- log_file = sys.stdout
+ self.log_file = sys.stdout
- self.launcher.SetOutputFile(log_file)
+ self.launcher.SetOutputFile(self.log_file)
self.launcher.Run()
+ # This is watched for in webdriver_benchmark_test.py
+ sys.stdout.write("partial_layout_benchmark TEST COMPLETE\n")
finally:
if to_close:
to_close.close()
@@ -195,6 +198,8 @@
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:
diff --git a/src/cobalt/webdriver_benchmarks/tests/all.py b/src/cobalt/webdriver_benchmarks/tests/all.py
new file mode 100755
index 0000000..78924c0
--- /dev/null
+++ b/src/cobalt/webdriver_benchmarks/tests/all.py
@@ -0,0 +1,38 @@
+#!/usr/bin/python2
+"""Target for running all tests 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
+
+
+# pylint: disable=unused-argument
+def load_tests(loader, tests, pattern):
+ """This is a Python unittest "load_tests protocol method."""
+ s = unittest.TestSuite()
+
+ for f in os.listdir(os.path.dirname(__file__)):
+ if not f.endswith(".py"):
+ continue
+ if f.startswith("_"):
+ continue
+ if f == "all.py":
+ continue
+ s.addTest(unittest.TestLoader().loadTestsFromModule(
+ importlib.import_module("tests." + f[:-3])))
+ return s
+
+if __name__ == "__main__":
+ tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/guide.py b/src/cobalt/webdriver_benchmarks/tests/guide.py
new file mode 100755
index 0000000..442eef1
--- /dev/null
+++ b/src/cobalt/webdriver_benchmarks/tests/guide.py
@@ -0,0 +1,48 @@
+#!/usr/bin/python2
+"""Simple guide navigation test."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import sys
+
+# 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
+import tv_testcase
+import partial_layout_benchmark
+
+# selenium imports
+keys = partial_layout_benchmark.ImportSeleniumModule("webdriver.common.keys")
+
+REPEAT_COUNT = 10
+
+
+class GuideTest(tv_testcase.TvTestCase):
+
+ def test_simple(self):
+ self.load_tv()
+ self.assert_displayed(tv.FOCUSED_SHELF)
+
+ print(str(self.get_webdriver().execute_script(
+ "h5vcc.system.recordStats = true")))
+
+ for _ in xrange(REPEAT_COUNT):
+ self.send_keys(tv.FOCUSED_SHELF, keys.Keys.ARROW_LEFT)
+ self.assert_displayed(tv.FOCUSED_GUIDE)
+ self.wait_for_layout_complete()
+ self.send_keys(tv.FOCUSED_GUIDE, keys.Keys.ARROW_RIGHT)
+ self.poll_until_found(tv.FOCUSED_SHELF)
+ self.assert_displayed(tv.FOCUSED_SHELF_TITLE)
+ self.wait_for_layout_complete()
+
+ self.record_results("GuideTest.test_simple")
+
+
+if __name__ == "__main__":
+ tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tests/shelf.py b/src/cobalt/webdriver_benchmarks/tests/shelf.py
index b81478b..b47e379 100755
--- a/src/cobalt/webdriver_benchmarks/tests/shelf.py
+++ b/src/cobalt/webdriver_benchmarks/tests/shelf.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python2
"""Simple shelf navigation test."""
from __future__ import absolute_import
@@ -7,7 +7,6 @@
import os
import sys
-import time
# The parent directory is a module
sys.path.insert(0, os.path.dirname(os.path.dirname(
@@ -27,11 +26,6 @@
class ShelfTest(tv_testcase.TvTestCase):
- def _wait_for_layout(self):
- while int(self.get_webdriver().execute_script(
- "return h5vcc.cVal.getValue('Event.MainWebModule.IsProcessing')")):
- time.sleep(0.1)
-
def test_simple(self):
self.load_tv()
self.assert_displayed(tv.FOCUSED_SHELF)
@@ -43,18 +37,16 @@
self.send_keys(tv.FOCUSED_SHELF, keys.Keys.ARROW_DOWN)
self.poll_until_found(tv.FOCUSED_SHELF)
self.assert_displayed(tv.FOCUSED_SHELF_TITLE)
- self._wait_for_layout()
+ self.wait_for_layout_complete()
for _ in xrange(SHELF_ITEMS_COUNT):
self.send_keys(tv.FOCUSED_TILE, keys.Keys.ARROW_RIGHT)
self.poll_until_found(tv.FOCUSED_TILE)
self.assert_displayed(tv.FOCUSED_SHELF_TITLE)
- self._wait_for_layout()
+ self.wait_for_layout_complete()
- print("ShelfTest event durations"
- + str(self.get_webdriver().execute_script(
- "return h5vcc.cVal.getValue("
- "'Event.Durations.MainWebModule.KeyUp')")))
+ self.record_results("ShelfTest.test_simple")
+
if __name__ == "__main__":
tv_testcase.main()
diff --git a/src/cobalt/webdriver_benchmarks/tv_testcase.py b/src/cobalt/webdriver_benchmarks/tv_testcase.py
index 39bfe41..23649ec 100644
--- a/src/cobalt/webdriver_benchmarks/tv_testcase.py
+++ b/src/cobalt/webdriver_benchmarks/tv_testcase.py
@@ -27,6 +27,7 @@
BASE_URL = "https://www.youtube.com/tv"
PAGE_LOAD_WAIT_SECONDS = 30
+LAYOUT_TIMEOUT_SECONDS = 5
class TvTestCase(unittest.TestCase):
@@ -36,6 +37,9 @@
with an internal class with the same name.
"""
+ class LayoutTimeoutException(BaseException):
+ """Exception thrown when layout did not complete in time."""
+
def get_webdriver(self):
return partial_layout_benchmark.GetWebDriver()
@@ -127,6 +131,10 @@
could not be immediately found. If the retries do not succeed,
the underlying exception is passed through.
+ Args:
+ css_selector: A CSS selector
+ keys: key events
+
Raises:
Underlying WebDriver exceptions
"""
@@ -144,6 +152,30 @@
raise
time.sleep(1)
+ def wait_for_layout_complete(self):
+ """Waits for Cobalt to complete pending layouts."""
+ start_time = time.time()
+ while int(self.get_webdriver().execute_script(
+ "return h5vcc.cVal.getValue('Event.MainWebModule.IsProcessing')")):
+
+ if time.time() - start_time > LAYOUT_TIMEOUT_SECONDS:
+ raise TvTestCase.LayoutTimeoutException()
+
+ time.sleep(0.1)
+
+ def record_results(self, name):
+ """Records results of benchmark.
+
+ The duration of KeyUp events will be recorded.
+
+ Args:
+ name: name of test case
+ """
+ print("tv_testcase RESULT: " + name + " "
+ + str(self.get_webdriver().execute_script(
+ "return h5vcc.cVal.getValue("
+ "'Event.Durations.MainWebModule.KeyUp')")))
+
def main():
partial_layout_benchmark.main()
diff --git a/src/media/base/shell_audio_bus.h b/src/media/base/shell_audio_bus.h
index 6c43f8c..16c7012 100644
--- a/src/media/base/shell_audio_bus.h
+++ b/src/media/base/shell_audio_bus.h
@@ -59,6 +59,7 @@
size_t channels() const { return channels_; }
size_t frames() const { return frames_; }
+ SampleType sample_type() const { return sample_type_; }
size_t GetSampleSizeInBytes() const;
const uint8* interleaved_data() const;
const uint8* planar_data(size_t channel) const;
diff --git a/src/starboard/shared/posix/log_raw.cc b/src/starboard/shared/posix/log_raw.cc
index 10cfff0..f790d78 100644
--- a/src/starboard/shared/posix/log_raw.cc
+++ b/src/starboard/shared/posix/log_raw.cc
@@ -23,14 +23,13 @@
// Cribbed from base/logging.cc's RawLog() function.
size_t bytes_written = 0;
const size_t message_len = strlen(message);
- int rv;
while (bytes_written < message_len) {
- rv = HANDLE_EINTR(write(STDERR_FILENO, message + bytes_written,
- message_len - bytes_written));
- if (rv < 0) {
+ int retval = HANDLE_EINTR(write(STDERR_FILENO, message + bytes_written,
+ message_len - bytes_written));
+ if (retval < 0) {
// Give up, nothing we can do now.
break;
}
- bytes_written += rv;
+ bytes_written += retval;
}
}
