Hook up the scheduler component to html_viewer

components/html_viewer/blink_platform_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.
 
 #include "components/html_viewer/blink_platform_impl.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "components/html_viewer/blink_resource_constants.h"
 #include "components/html_viewer/web_clipboard_impl.h"
 #include "components/html_viewer/web_cookie_jar_impl.h"
 #include "components/html_viewer/web_message_port_channel_impl.h"
 #include "components/html_viewer/web_socket_handle_impl.h"
-#include "components/html_viewer/web_thread_impl.h"
 #include "components/html_viewer/web_url_loader_impl.h"
+#include "components/scheduler/child/webthread_impl_for_worker_scheduler.h"
+#include "components/scheduler/renderer/renderer_scheduler.h"
+#include "components/scheduler/renderer/webthread_impl_for_renderer_scheduler.h"
 #include "net/base/data_url.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "third_party/WebKit/public/platform/WebWaitableEvent.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/application_impl.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/connect.h"
 #include "ui/events/gestures/blink/web_gesture_curve_impl.h"
 
 namespace html_viewer {
@@ skipping 19 matching lines @@
     return impl_.get();
   }
 
  private:
   scoped_ptr<base::WaitableEvent> impl_;
   DISALLOW_COPY_AND_ASSIGN(WebWaitableEventImpl);
 };
 
 }  // namespace
 
-BlinkPlatformImpl::BlinkPlatformImpl(mojo::ApplicationImpl* app)
-    : main_loop_(base::MessageLoop::current()),
+BlinkPlatformImpl::BlinkPlatformImpl(
+    mojo::ApplicationImpl* app,
+    scheduler::RendererScheduler* renderer_scheduler)
+    : main_thread_task_runner_(renderer_scheduler->DefaultTaskRunner()),
+      main_thread_(
+          new scheduler::WebThreadImplForRendererScheduler(renderer_scheduler)),
       shared_timer_func_(NULL),
       shared_timer_fire_time_(0.0),
       shared_timer_fire_time_was_set_while_suspended_(false),
-      shared_timer_suspended_(0),
-      current_thread_slot_(&DestroyCurrentThread),
-      scheduler_(main_loop_->message_loop_proxy()) {
+      shared_timer_suspended_(0) {
   if (app) {
     app->ConnectToService("mojo:network_service", &network_service_);
 
     mojo::CookieStorePtr cookie_store;
     network_service_->GetCookieStore(GetProxy(&cookie_store));
     cookie_jar_.reset(new WebCookieJarImpl(cookie_store.Pass()));
 
     mojo::ServiceProviderPtr service_provider;
     app->ConnectToService("mojo:core_services", &service_provider);
     mojo::ClipboardPtr clipboard;
     mojo::ConnectToService(service_provider.get(), &clipboard);
     clipboard_.reset(new WebClipboardImpl(clipboard.Pass()));
   }
+  if (main_thread_task_runner_.get())

[Sami, 2015/04/28 15:20:21]

This should never be null.

+    shared_timer_.SetTaskRunner(main_thread_task_runner_);
 }
 
 BlinkPlatformImpl::~BlinkPlatformImpl() {
 }
 
 blink::WebCookieJar* BlinkPlatformImpl::cookieJar() {
   return cookie_jar_.get();
 }
 
 blink::WebClipboard* BlinkPlatformImpl::clipboard() {
   return clipboard_.get();
 }
 
 blink::WebMimeRegistry* BlinkPlatformImpl::mimeRegistry() {
   return &mime_registry_;
 }
 
 blink::WebThemeEngine* BlinkPlatformImpl::themeEngine() {
   return &theme_engine_;
 }
 
-blink::WebScheduler* BlinkPlatformImpl::scheduler() {
-  return &scheduler_;
-}
-
 blink::WebString BlinkPlatformImpl::defaultLocale() {
   return blink::WebString::fromUTF8("en-US");
 }
 
 blink::WebBlobRegistry* BlinkPlatformImpl::blobRegistry() {
   return &blob_registry_;
 }
 
 double BlinkPlatformImpl::currentTime() {
   return base::Time::Now().ToDoubleT();
@@ skipping 42 matching lines @@
   shared_timer_.Start(FROM_HERE, base::TimeDelta::FromMicroseconds(interval),
                       this, &BlinkPlatformImpl::DoTimeout);
 }
 
 void BlinkPlatformImpl::stopSharedTimer() {
   shared_timer_.Stop();
 }
 
 void BlinkPlatformImpl::callOnMainThread(
     void (*func)(void*), void* context) {
-  main_loop_->PostTask(FROM_HERE, base::Bind(func, context));
+  main_thread_task_runner_->PostTask(FROM_HERE, base::Bind(func, context));
 }
 
 bool BlinkPlatformImpl::isThreadedCompositingEnabled() {
   return true;
 }
 
 blink::WebCompositorSupport* BlinkPlatformImpl::compositorSupport() {
   return &compositor_support_;
 }
 
@@ skipping 71 matching lines @@
 
 bool BlinkPlatformImpl::isReservedIPAddress(
     const blink::WebString& host) const {
   net::IPAddressNumber address;
   if (!net::ParseURLHostnameToNumber(host.utf8(), &address))
     return false;
   return net::IsIPAddressReserved(address);
 }
 
 blink::WebThread* BlinkPlatformImpl::createThread(const char* name) {
-  return new WebThreadImpl(name);
+  scheduler::WebThreadImplForWorkerScheduler* thread =
+      new scheduler::WebThreadImplForWorkerScheduler(name);
+  thread->TaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&BlinkPlatformImpl::UpdateWebThreadTLS,
+                            base::Unretained(this), thread));
+  return thread;
 }
 
 blink::WebThread* BlinkPlatformImpl::currentThread() {
-  WebThreadImplForMessageLoop* thread =
-      static_cast<WebThreadImplForMessageLoop*>(current_thread_slot_.Get());
-  if (thread)
-    return (thread);
-
-  scoped_refptr<base::MessageLoopProxy> message_loop =
-      base::MessageLoopProxy::current();
-  if (!message_loop.get())
-    return NULL;
-
-  thread = new WebThreadImplForMessageLoop(message_loop.get());
-  current_thread_slot_.Set(thread);
-  return thread;
+  if (main_thread_->isCurrentThread())
+    return main_thread_.get();
+  return static_cast<blink::WebThread*>(current_thread_slot_.Get());
 }
 
 void BlinkPlatformImpl::yieldCurrentThread() {
   base::PlatformThread::YieldCurrentThread();
 }
 
 blink::WebWaitableEvent* BlinkPlatformImpl::createWaitableEvent() {
   return new WebWaitableEventImpl();
 }
 
@@ skipping 21 matching lines @@
 
 blink::WebCrypto* BlinkPlatformImpl::crypto() {
   return &web_crypto_;
 }
 
 blink::WebNotificationManager*
 BlinkPlatformImpl::notificationManager() {
   return &web_notification_manager_;
 }
 
-// static
-void BlinkPlatformImpl::DestroyCurrentThread(void* thread) {
-  WebThreadImplForMessageLoop* impl =
-      static_cast<WebThreadImplForMessageLoop*>(thread);
-  delete impl;
+void BlinkPlatformImpl::UpdateWebThreadTLS(blink::WebThread* thread) {
+  DCHECK(!current_thread_slot_.Get());
+  current_thread_slot_.Set(thread);
 }
 
 }  // namespace html_viewer