Another stab at the Chromium side of storage events. The WebKit side can be ...

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"
 #include "chrome/browser/in_process_webkit/storage_namespace.h"
 #include "chrome/browser/in_process_webkit/webkit_thread.h"
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 #include "chrome/common/render_messages.h"
 
+DOMStorageDispatcherHost* DOMStorageDispatcherHost::current_ = NULL;
+
+DOMStorageDispatcherHost::
+AutoSetCurrentDispatcherHost::AutoSetCurrentDispatcherHost(
+    DOMStorageDispatcherHost* dispatcher_host) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
+  DCHECK(!current_);
+  current_ = dispatcher_host;
+}
+
+DOMStorageDispatcherHost::
+AutoSetCurrentDispatcherHost::~AutoSetCurrentDispatcherHost() {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
+  DCHECK(current_);
+  current_ = NULL;
+}
+
 DOMStorageDispatcherHost::DOMStorageDispatcherHost(
     IPC::Message::Sender* message_sender, WebKitContext* webkit_context,
     WebKitThread* webkit_thread)
     : webkit_context_(webkit_context),
       webkit_thread_(webkit_thread),
       message_sender_(message_sender),
       process_handle_(0),
       ever_used_(false),
       shutdown_(false) {
   DCHECK(webkit_context_.get());
   DCHECK(webkit_thread_);
   DCHECK(message_sender_);
 }
 
 DOMStorageDispatcherHost::~DOMStorageDispatcherHost() {
   DCHECK(shutdown_);
 }
 
 void DOMStorageDispatcherHost::Init(base::ProcessHandle process_handle) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+  Context()->RegisterDispatcherHost(this);
+
   DCHECK(!process_handle_);
   process_handle_ = process_handle;
   DCHECK(process_handle_);
 }
 
 void DOMStorageDispatcherHost::Shutdown() {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
+    Context()->UnregisterDispatcherHost(this);
     message_sender_ = NULL;
     if (!ever_used_) {
       // No need to (possibly) spin up the WebKit thread for a no-op.
       shutdown_ = true;
       return;
     }
 
     MessageLoop* webkit_loop = webkit_thread_->GetMessageLoop();
     webkit_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
         &DOMStorageDispatcherHost::Shutdown));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   DCHECK(ever_used_);
   DCHECK(!message_sender_);
   DCHECK(!shutdown_);
   shutdown_ = true;
 
-  // TODO(jorlow): If we have any locks or are tracking resources that need to
-  //               be released on the WebKit thread, do it here.
+  // TODO(jorlow): Do stuff that needs to be run on the WebKit thread.  Locks
+  //               and others will likely need this, so let's not delete this
+  //               code even though it doesn't do anyting yet.
 }
 
-bool DOMStorageDispatcherHost::OnMessageReceived(
-    const IPC::Message& message, bool *msg_is_ok) {
+/* static */
+void DOMStorageDispatcherHost::DispatchStorageEvent(const string16& key,
+    const NullableString16& old_value, const NullableString16& new_value,
+    const string16& origin, bool is_local_storage) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
+  DCHECK(current_);
+  current_->webkit_thread_->PostIOThreadTask(FROM_HERE, NewRunnableMethod(
+        current_, &DOMStorageDispatcherHost::OnStorageEvent, key, old_value,
+        new_value, origin, is_local_storage));
+}
+
+bool DOMStorageDispatcherHost::OnMessageReceived(const IPC::Message& message,
+                                                 bool *msg_is_ok) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(!shutdown_);
   DCHECK(process_handle_);
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(DOMStorageDispatcherHost, message, *msg_is_ok)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageNamespaceId,
                                     OnNamespaceId)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageCloneNamespaceId,
                                     OnCloneNamespaceId)
@@ skipping 188 matching lines @@
   }
 
   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;
   }
+
+  AutoSetCurrentDispatcherHost auto_set(this);
   storage_area->SetItem(key, value, &quota_exception);
   DCHECK(!quota_exception);  // This is tracked by the renderer.
 }
 
 void DOMStorageDispatcherHost::OnRemoveItem(int64 storage_area_id,
                                             const string16& key) {
   DCHECK(!shutdown_);
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     MessageLoop* webkit_loop = webkit_thread_->GetMessageLoop();
     webkit_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
         &DOMStorageDispatcherHost::OnRemoveItem, storage_area_id, key));
     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;
   }
+
+  AutoSetCurrentDispatcherHost auto_set(this);
   storage_area->RemoveItem(key);
 }
 
 void DOMStorageDispatcherHost::OnClear(int64 storage_area_id) {
   DCHECK(!shutdown_);
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     MessageLoop* webkit_loop = webkit_thread_->GetMessageLoop();
     webkit_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
         &DOMStorageDispatcherHost::OnClear, storage_area_id));
     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;
   }
+
+  AutoSetCurrentDispatcherHost auto_set(this);
   storage_area->Clear();
 }
+
+void DOMStorageDispatcherHost::OnStorageEvent(const string16& key,
+    const NullableString16& old_value, const NullableString16& new_value,
+    const string16& origin, bool is_local_storage) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+  DCHECK(is_local_storage);  // Only LocalStorage is implemented right now.
+  DOMStorageType dom_storage_type = is_local_storage ? DOM_STORAGE_LOCAL
+                                                     : DOM_STORAGE_SESSION;
+  const DOMStorageContext::DispatcherHostSet* set =
+      Context()->GetDispatcherHostSet();
+  DOMStorageContext::DispatcherHostSet::const_iterator cur = set->begin();
+  while (cur != set->end()) {
+    (*cur)->Send(new ViewMsg_DOMStorageEvent(key, old_value, new_value, origin,
+                                             dom_storage_type));
+    ++cur;
+  }
+}