diff options
Diffstat (limited to 'chromium/content/browser/service_worker/embedded_worker_instance_unittest.cc')
-rw-r--r-- | chromium/content/browser/service_worker/embedded_worker_instance_unittest.cc | 166 |
1 files changed, 98 insertions, 68 deletions
diff --git a/chromium/content/browser/service_worker/embedded_worker_instance_unittest.cc b/chromium/content/browser/service_worker/embedded_worker_instance_unittest.cc index 45b2f29dc7f..d14ccd22f25 100644 --- a/chromium/content/browser/service_worker/embedded_worker_instance_unittest.cc +++ b/chromium/content/browser/service_worker/embedded_worker_instance_unittest.cc @@ -3,43 +3,21 @@ // found in the LICENSE file. #include "base/basictypes.h" +#include "base/run_loop.h" #include "base/stl_util.h" #include "content/browser/service_worker/embedded_worker_instance.h" #include "content/browser/service_worker/embedded_worker_registry.h" +#include "content/browser/service_worker/embedded_worker_test_helper.h" #include "content/browser/service_worker/service_worker_context_core.h" -#include "content/common/service_worker_messages.h" +#include "content/browser/service_worker/service_worker_context_wrapper.h" +#include "content/common/service_worker/embedded_worker_messages.h" #include "content/public/test/test_browser_thread_bundle.h" -#include "ipc/ipc_message.h" -#include "ipc/ipc_sender.h" +#include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" namespace content { -namespace { - -typedef std::vector<IPC::Message*> MessageList; - -class FakeSender : public IPC::Sender { - public: - FakeSender() {} - virtual ~FakeSender() { - STLDeleteContainerPointers(sent_messages_.begin(), sent_messages_.end()); - } - - // IPC::Sender implementation. - virtual bool Send(IPC::Message* message) OVERRIDE { - sent_messages_.push_back(message); - return true; - } - - const MessageList& sent_messages() { return sent_messages_; } - - private: - MessageList sent_messages_; - DISALLOW_COPY_AND_ASSIGN(FakeSender); -}; - -} // namespace +static const int kRenderProcessId = 11; class EmbeddedWorkerInstanceTest : public testing::Test { protected: @@ -47,91 +25,143 @@ class EmbeddedWorkerInstanceTest : public testing::Test { : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} virtual void SetUp() OVERRIDE { - context_.reset(new ServiceWorkerContextCore(base::FilePath(), NULL)); + helper_.reset(new EmbeddedWorkerTestHelper(kRenderProcessId)); } virtual void TearDown() OVERRIDE { - context_.reset(); + helper_.reset(); } + ServiceWorkerContextCore* context() { return helper_->context(); } + EmbeddedWorkerRegistry* embedded_worker_registry() { - DCHECK(context_); - return context_->embedded_worker_registry(); + DCHECK(context()); + return context()->embedded_worker_registry(); } + IPC::TestSink* ipc_sink() { return helper_->ipc_sink(); } + TestBrowserThreadBundle thread_bundle_; - scoped_ptr<ServiceWorkerContextCore> context_; + scoped_ptr<EmbeddedWorkerTestHelper> helper_; DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerInstanceTest); }; +static void SaveStatusAndCall(ServiceWorkerStatusCode* out, + const base::Closure& callback, + ServiceWorkerStatusCode status) { + *out = status; + callback.Run(); +} + TEST_F(EmbeddedWorkerInstanceTest, StartAndStop) { scoped_ptr<EmbeddedWorkerInstance> worker = embedded_worker_registry()->CreateWorker(); EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status()); - FakeSender fake_sender; - const int process_id = 11; - const int thread_id = 33; + const int embedded_worker_id = worker->embedded_worker_id(); const int64 service_worker_version_id = 55L; + const GURL scope("http://example.com/*"); const GURL url("http://example.com/worker.js"); - // This fails as we have no available process yet. - EXPECT_FALSE(worker->Start(service_worker_version_id, url)); - EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status()); - // Simulate adding one process to the worker. - worker->AddProcessReference(process_id); - embedded_worker_registry()->AddChildProcessSender(process_id, &fake_sender); + helper_->SimulateAddProcessToWorker(embedded_worker_id, kRenderProcessId); // Start should succeed. - EXPECT_TRUE(worker->Start(service_worker_version_id, url)); + ServiceWorkerStatusCode status; + base::RunLoop run_loop; + worker->Start( + service_worker_version_id, + scope, + url, + std::vector<int>(), + base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); + run_loop.Run(); + EXPECT_EQ(SERVICE_WORKER_OK, status); EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status()); + base::RunLoop().RunUntilIdle(); - // Simulate an upcall from embedded worker to notify that it's started. - worker->OnStarted(thread_id); + // Worker started message should be notified (by EmbeddedWorkerTestHelper). EXPECT_EQ(EmbeddedWorkerInstance::RUNNING, worker->status()); - EXPECT_EQ(process_id, worker->process_id()); - EXPECT_EQ(thread_id, worker->thread_id()); + EXPECT_EQ(kRenderProcessId, worker->process_id()); // Stop the worker. - EXPECT_TRUE(worker->Stop()); + EXPECT_EQ(SERVICE_WORKER_OK, worker->Stop()); EXPECT_EQ(EmbeddedWorkerInstance::STOPPING, worker->status()); + base::RunLoop().RunUntilIdle(); - // Simulate an upcall from embedded worker to notify that it's stopped. - worker->OnStopped(); + // Worker stopped message should be notified (by EmbeddedWorkerTestHelper). EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status()); // Verify that we've sent two messages to start and terminate the worker. - const MessageList& messages = fake_sender.sent_messages(); - ASSERT_EQ(2U, messages.size()); - ASSERT_EQ(ServiceWorkerMsg_StartWorker::ID, messages[0]->type()); - ASSERT_EQ(ServiceWorkerMsg_TerminateWorker::ID, messages[1]->type()); + ASSERT_TRUE(ipc_sink()->GetUniqueMessageMatching( + EmbeddedWorkerMsg_StartWorker::ID)); + ASSERT_TRUE(ipc_sink()->GetUniqueMessageMatching( + EmbeddedWorkerMsg_StopWorker::ID)); } -TEST_F(EmbeddedWorkerInstanceTest, ChooseProcess) { +TEST_F(EmbeddedWorkerInstanceTest, InstanceDestroyedBeforeStartFinishes) { scoped_ptr<EmbeddedWorkerInstance> worker = embedded_worker_registry()->CreateWorker(); EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status()); - FakeSender fake_sender; + const int64 service_worker_version_id = 55L; + const GURL scope("http://example.com/*"); + const GURL url("http://example.com/worker.js"); + + ServiceWorkerStatusCode status; + base::RunLoop run_loop; + // Begin starting the worker. + std::vector<int> available_process; + available_process.push_back(kRenderProcessId); + worker->Start( + service_worker_version_id, + scope, + url, + available_process, + base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure())); + // But destroy it before it gets a chance to complete. + worker.reset(); + run_loop.Run(); + EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT, status); + + // Verify that we didn't send the message to start the worker. + ASSERT_FALSE( + ipc_sink()->GetUniqueMessageMatching(EmbeddedWorkerMsg_StartWorker::ID)); +} + +TEST_F(EmbeddedWorkerInstanceTest, SortProcesses) { + scoped_ptr<EmbeddedWorkerInstance> worker = + embedded_worker_registry()->CreateWorker(); + EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status()); // Simulate adding processes to the worker. // Process 1 has 1 ref, 2 has 2 refs and 3 has 3 refs. - worker->AddProcessReference(1); - worker->AddProcessReference(2); - worker->AddProcessReference(2); - worker->AddProcessReference(3); - worker->AddProcessReference(3); - worker->AddProcessReference(3); - embedded_worker_registry()->AddChildProcessSender(1, &fake_sender); - embedded_worker_registry()->AddChildProcessSender(2, &fake_sender); - embedded_worker_registry()->AddChildProcessSender(3, &fake_sender); + const int embedded_worker_id = worker->embedded_worker_id(); + helper_->SimulateAddProcessToWorker(embedded_worker_id, 1); + helper_->SimulateAddProcessToWorker(embedded_worker_id, 2); + helper_->SimulateAddProcessToWorker(embedded_worker_id, 2); + helper_->SimulateAddProcessToWorker(embedded_worker_id, 3); + helper_->SimulateAddProcessToWorker(embedded_worker_id, 3); + helper_->SimulateAddProcessToWorker(embedded_worker_id, 3); // Process 3 has the biggest # of references and it should be chosen. - EXPECT_TRUE(worker->Start(1L, GURL("http://example.com/worker.js"))); - EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status()); - EXPECT_EQ(3, worker->process_id()); + EXPECT_THAT(worker->SortProcesses(std::vector<int>()), + testing::ElementsAre(3, 2, 1)); + EXPECT_EQ(-1, worker->process_id()); + + // Argument processes are added to the existing set, but only for a single + // call. + std::vector<int> registering_processes; + registering_processes.push_back(1); + registering_processes.push_back(1); + registering_processes.push_back(1); + registering_processes.push_back(4); + EXPECT_THAT(worker->SortProcesses(registering_processes), + testing::ElementsAre(1, 3, 2, 4)); + + EXPECT_THAT(worker->SortProcesses(std::vector<int>()), + testing::ElementsAre(3, 2, 1)); } } // namespace content |