Start the WebKit thread when we initialize the resource dispatcher host

chrome/browser/in_process_webkit/dom_storage_dispatcher_host.cc

 // Copyright (c) 2009 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 "chrome/browser/in_process_webkit/dom_storage_dispatcher_host.h"
 
 #include "base/nullable_string16.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/in_process_webkit/dom_storage_context.h"
 #include "chrome/browser/in_process_webkit/storage_area.h"
@@ skipping 132 matching lines @@
   // The IO thread can't go away while the WebKit thread is still running.
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this, &DOMStorageDispatcherHost::Send, message));
 }
 
 void DOMStorageDispatcherHost::OnNamespaceId(DOMStorageType storage_type,
                                              IPC::Message* reply_msg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnNamespaceId,
-        storage_type, reply_msg));
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnNamespaceId, storage_type,
+        reply_msg));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageNamespace* new_namespace;
   if (storage_type == DOM_STORAGE_LOCAL)
     new_namespace = Context()->LocalStorage();
   else
     new_namespace = Context()->NewSessionStorage();
   ViewHostMsg_DOMStorageNamespaceId::WriteReplyParams(reply_msg,
                                                       new_namespace->id());
   Send(reply_msg);
 }
 
 void DOMStorageDispatcherHost::OnCloneNamespaceId(int64 namespace_id,
                                                   IPC::Message* reply_msg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnCloneNamespaceId,
-        namespace_id, reply_msg));
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnCloneNamespaceId, namespace_id,
+        reply_msg));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageNamespace* existing_namespace =
       Context()->GetStorageNamespace(namespace_id);
   if (!existing_namespace) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageCloneNamespaceId::ID, process_handle_);
     delete reply_msg;
     return;
   }
   StorageNamespace* new_namespace = existing_namespace->Copy();
   ViewHostMsg_DOMStorageCloneNamespaceId::WriteReplyParams(reply_msg,
                                                            new_namespace->id());
   Send(reply_msg);
 }
 
 void DOMStorageDispatcherHost::OnStorageAreaId(int64 namespace_id,
                                                const string16& origin,
                                                IPC::Message* reply_msg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnStorageAreaId,
-        namespace_id, origin, reply_msg));
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnStorageAreaId, namespace_id, origin,
+        reply_msg));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageNamespace* storage_namespace =
       Context()->GetStorageNamespace(namespace_id);
   if (!storage_namespace) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageStorageAreaId::ID, process_handle_);
     delete reply_msg;
     return;
   }
   StorageArea* storage_area = storage_namespace->GetStorageArea(origin);
   ViewHostMsg_DOMStorageCloneNamespaceId::WriteReplyParams(reply_msg,
                                                            storage_area->id());
   Send(reply_msg);
 }
 
 void DOMStorageDispatcherHost::OnLength(int64 storage_area_id,
                                         IPC::Message* reply_msg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnLength, storage_area_id, reply_msg));
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnLength, storage_area_id, reply_msg));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
   if (!storage_area) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageLength::ID, process_handle_);
     delete reply_msg;
     return;
   }
   unsigned length = storage_area->Length();
   ViewHostMsg_DOMStorageLength::WriteReplyParams(reply_msg, length);
   Send(reply_msg);
 }
 
 void DOMStorageDispatcherHost::OnKey(int64 storage_area_id, unsigned index,
                                      IPC::Message* reply_msg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnKey, storage_area_id, index, reply_msg));
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnKey, storage_area_id, index,
+        reply_msg));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
   if (!storage_area) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageKey::ID, process_handle_);
     delete reply_msg;
     return;
   }
   const NullableString16& key = storage_area->Key(index);
   ViewHostMsg_DOMStorageKey::WriteReplyParams(reply_msg, key);
   Send(reply_msg);
 }
 
 void DOMStorageDispatcherHost::OnGetItem(int64 storage_area_id,
                                          const string16& key,
                                          IPC::Message* reply_msg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnGetItem,
-        storage_area_id, key, reply_msg));
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnGetItem, storage_area_id, key,
+        reply_msg));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
   if (!storage_area) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageGetItem::ID, process_handle_);
     delete reply_msg;
     return;
   }
   const NullableString16& value = storage_area->GetItem(key);
   ViewHostMsg_DOMStorageGetItem::WriteReplyParams(reply_msg, value);
   Send(reply_msg);
 }
 
 void DOMStorageDispatcherHost::OnSetItem(
     int64 storage_area_id, const string16& key, const string16& value,
     const GURL& url, IPC::Message* reply_msg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnSetItem, storage_area_id, key, value,
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnSetItem, storage_area_id, key, value,
         url, reply_msg));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   bool quota_exception = false;
   StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
   if (!storage_area) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageSetItem::ID, process_handle_);
     return;
   }
 
   ScopedStorageEventContext scope(this, &url);
   storage_area->SetItem(key, value, &quota_exception);
   ViewHostMsg_DOMStorageSetItem::WriteReplyParams(reply_msg, quota_exception);
   Send(reply_msg);
 }
 
 void DOMStorageDispatcherHost::OnRemoveItem(
     int64 storage_area_id, const string16& key, const GURL& url) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnRemoveItem, storage_area_id, key, url));
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnRemoveItem, storage_area_id, key,
+        url));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
   if (!storage_area) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageRemoveItem::ID, process_handle_);
     return;
   }
 
   ScopedStorageEventContext scope(this, &url);
   storage_area->RemoveItem(key);
 }
 
 void DOMStorageDispatcherHost::OnClear(int64 storage_area_id, const GURL& url) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    PostTaskToWebKitThread(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnClear, storage_area_id, url));
+    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
+        this, &DOMStorageDispatcherHost::OnClear, storage_area_id, url));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
   if (!storage_area) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageClear::ID, process_handle_);
     return;
   }
 
   ScopedStorageEventContext scope(this, &url);
   storage_area->Clear();
 }
 
 void DOMStorageDispatcherHost::OnStorageEvent(
     const ViewMsg_DOMStorageEvent_Params& params) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   const DOMStorageContext::DispatcherHostSet* set =
       Context()->GetDispatcherHostSet();
   DOMStorageContext::DispatcherHostSet::const_iterator cur = set->begin();
   while (cur != set->end()) {
     (*cur)->Send(new ViewMsg_DOMStorageEvent(params));
     ++cur;
   }
 }
-
-void DOMStorageDispatcherHost::PostTaskToWebKitThread(
-    const tracked_objects::Location& from_here, Task* task) {
-  webkit_thread_->EnsureInitialized();
-  ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, task);
-}