web-threads: Create a single instance of WebThread for each blink thread.

content/child/webthread_impl.cc

 // Copyright 2014 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.
 
 // An implementation of WebThread in terms of base::MessageLoop and
 // base::Thread
 
 #include "content/child/webthread_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/message_loop/message_loop.h"
 #include "base/pending_task.h"
 #include "base/threading/platform_thread.h"
 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
 
 namespace content {
 
 class WebThreadBase::TaskObserverAdapter
     : public base::MessageLoop::TaskObserver {
  public:
   TaskObserverAdapter(WebThread::TaskObserver* observer)
@@ skipping 87 matching lines @@
                                     Task* task,
                                     long long delay_ms) {
   tracked_objects::Location location(web_location.functionName(),
                                      web_location.fileName(), -1, nullptr);
   TaskRunner()->PostDelayedTask(
       location,
       base::Bind(RunWebThreadTask, base::Passed(make_scoped_ptr(task))),
       base::TimeDelta::FromMilliseconds(delay_ms));
 }
 
 void WebThreadBase::enterRunLoop() {

[kinuko, 2015/02/27 09:54:27]

Is this now used only for unit tests? If so I'd just add NOTREACHED() here and
remove MessageLoop virtual method from this interface.

[Sami, 2015/02/27 17:23:08]

There are a handful of tests on the Blink side which call this too. Perhaps it
would be worth renaming this to enterRunLoopForTesting() or something?

[sadrul, 2015/03/01 10:21:38]

I have filed http://crbug.com/462927 to remove enterRunLoop/exitRunLoop from
WebThread interface (also some related cleanup:
https://codereview.chromium.org/962053003/). Would it make sense to leave this
as is for now and do that cleanup separately?

   CHECK(isCurrentThread());
+  CHECK(MessageLoop());
   CHECK(!MessageLoop()->is_running());  // We don't support nesting.
   MessageLoop()->Run();
 }
 
 void WebThreadBase::exitRunLoop() {
   CHECK(isCurrentThread());
+  CHECK(MessageLoop());
   CHECK(MessageLoop()->is_running());
   MessageLoop()->Quit();
 }
 
 bool WebThreadBase::isCurrentThread() const {
   return TaskRunner()->BelongsToCurrentThread();
 }
 
 blink::PlatformThreadId WebThreadImpl::threadId() const {
   return thread_->thread_id();
 }
 
 WebThreadImpl::WebThreadImpl(const char* name)
     : thread_(new base::Thread(name)) {
   thread_->Start();
 }
 
 WebThreadImpl::~WebThreadImpl() {
   thread_->Stop();
 }
 
 base::MessageLoop* WebThreadImpl::MessageLoop() const {
-  return thread_->message_loop();
+  return nullptr;
 }
 
 base::SingleThreadTaskRunner* WebThreadImpl::TaskRunner() const {
   return thread_->message_loop_proxy().get();
 }
 
-WebThreadImplForMessageLoop::WebThreadImplForMessageLoop(
-    scoped_refptr<base::SingleThreadTaskRunner> owning_thread_task_runner)
-    : owning_thread_task_runner_(owning_thread_task_runner),
-      thread_id_(base::PlatformThread::CurrentId()) {
-}
-
-blink::PlatformThreadId WebThreadImplForMessageLoop::threadId() const {
-  return thread_id_;
-}
-
-WebThreadImplForMessageLoop::~WebThreadImplForMessageLoop() {
-}
-
-base::MessageLoop* WebThreadImplForMessageLoop::MessageLoop() const {
-  DCHECK(isCurrentThread());
-  return base::MessageLoop::current();
-}
-
-base::SingleThreadTaskRunner* WebThreadImplForMessageLoop::TaskRunner() const {
-  return owning_thread_task_runner_.get();
-}
-
 }  // namespace content