ServiceWorker: ignore AddMessageToConsole before process allocation

content/browser/service_worker/embedded_worker_instance_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/embedded_worker_instance.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
@@ skipping 728 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Worker should handle the sudden shutdown as detach.
   ASSERT_EQ(3u, events_.size());
   EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type);
   EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type);
   EXPECT_EQ(DETACHED, events_[2].type);
   EXPECT_EQ(EmbeddedWorkerStatus::STARTING, events_[2].status);
 }
 
+class StoreMessageInstanceClient
+    : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient {
+ public:
+  explicit StoreMessageInstanceClient(
+      base::WeakPtr<EmbeddedWorkerTestHelper> helper)
+      : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {}
+
+  const std::vector<std::pair<blink::WebConsoleMessage::Level, std::string>>&
+  message() {
+    return messages_;
+  }
+
+ private:
+  void AddMessageToConsole(blink::WebConsoleMessage::Level level,
+                           const std::string& message) override {
+    messages_.push_back(std::make_pair(level, message));
+  }
+
+  std::vector<std::pair<blink::WebConsoleMessage::Level, std::string>>
+      messages_;
+};
+
+TEST_F(EmbeddedWorkerInstanceTest, AddMessageToConsole) {
+  const int64_t version_id = 55L;
+  const GURL pattern("http://example.com/");
+  const GURL url("http://example.com/worker.js");
+  // Let StartWorker fail; binding is discarded in the middle of IPC

[falken, 2017/02/20 08:07:13]

I don't understand this comment: where is StartWorker called in lines 776-780?

nit: add a period at the end of the sentence.

[shimazu, 2017/02/21 03:13:53]

Sorry, it's just my copy-and-paste failure. Fixed.

+  std::unique_ptr<StoreMessageInstanceClient> instance_client =
+      base::MakeUnique<StoreMessageInstanceClient>(helper_->AsWeakPtr());
+  StoreMessageInstanceClient* instance_client_rawptr = instance_client.get();
+  helper_->RegisterMockInstanceClient(std::move(instance_client));
+  ASSERT_EQ(mock_instance_clients()->size(), 1UL);
+
+  std::unique_ptr<EmbeddedWorkerInstance> worker =
+      embedded_worker_registry()->CreateWorker();
+  helper_->SimulateAddProcessToPattern(pattern,
+                                       helper_->mock_render_process_id());
+  worker->AddListener(this);
+
+  // Attempt to start the worker and immediate AddMessageToConsole should not
+  // cause a crash.
+  std::pair<blink::WebConsoleMessage::Level, std::string> test_message =
+      std::make_pair(blink::WebConsoleMessage::LevelVerbose, "");
+  std::unique_ptr<EmbeddedWorkerStartParams> params =
+      CreateStartParams(version_id, pattern, url);
+  worker->Start(std::move(params), CreateEventDispatcher(),
+                base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+  worker->AddMessageToConsole(test_message.first, test_message.second);
+  base::RunLoop().RunUntilIdle();
+
+  // Messages sent before sending StartWorker message won't be dispatched.
+  ASSERT_EQ(0UL, instance_client_rawptr->message().size());
+  ASSERT_EQ(3UL, events_.size());
+  EXPECT_EQ(PROCESS_ALLOCATED, events_[0].type);
+  EXPECT_EQ(START_WORKER_MESSAGE_SENT, events_[1].type);
+  EXPECT_EQ(STARTED, events_[2].type);
+  EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, worker->status());
+
+  worker->AddMessageToConsole(test_message.first, test_message.second);
+  base::RunLoop().RunUntilIdle();
+
+  // Messages sent after sending StartWorker message should be reached to
+  // the renderer.
+  ASSERT_EQ(1UL, instance_client_rawptr->message().size());
+  EXPECT_EQ(test_message, instance_client_rawptr->message()[0]);
+
+  // Ensure the worker is stopped.
+  worker->Stop();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status());
+}
+
 }  // namespace content