[Background Sync] Use Mojo IPC to fire background sync events

content/renderer/background_sync/background_sync_client_impl.h

Index: content/renderer/background_sync/background_sync_client_impl.h
diff --git a/content/renderer/background_sync/background_sync_client_impl.h b/content/renderer/background_sync/background_sync_client_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..167f055ac6f9b3ff0117ec0b89b7a60467c34abc
--- /dev/null
+++ b/content/renderer/background_sync/background_sync_client_impl.h
@@ -0,0 +1,67 @@
+// Copyright 2015 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.
+
+#ifndef CONTENT_RENDERER_BACKGROUND_SYNC_BACKGROUND_SYNC_CLIENT_IMPL_H_
+#define CONTENT_RENDERER_BACKGROUND_SYNC_BACKGROUND_SYNC_CLIENT_IMPL_H_
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "content/common/background_sync_service.mojom.h"
+#include "content/common/content_export.h"
+#include "third_party/mojo/src/mojo/public/cpp/bindings/strong_binding.h"
+
+namespace content {
+
+// This class implements the mojo service for firing background sync events in a
+// service worker thread. It is constructed and lives on the renderer main
+// thread, but can dispatch to any worker thread to fire events.
+// Return messages from the workers are rerouted to the main thread in order to

[michaeln, 2015/06/24 02:02:05]

Routing everything, coming and going, thru the main renderer thread is very
unfortunate? The msg src/dst thread is always a worker thread.

I'd like to explore ways to eliminate the trips thru the main thread. It'd be
good to get an example of mojo usage that avoids those extra context switches
into the codebase because whatever pattern is used here will inevitably be
copied.

The technique we use for non-mojo based messaging involves filtering (with a
BrowserMessageFilter) IPCs on the IPC thread and then posting a task straight to
the destination thread. And using the ThreadSafeSender class to send messages
directly from background threads (which internally posts tasks to the IPC
thread).

I don't know enuf about mojo (yet) to know how to get that same runtime behavior
wrt thread switching, but peeling off interface ptrs for use on other threads
looks like it could be applicable?

[iclelland, 2015/06/24 14:29:30]

It is, and I'd like to get rid of it
That would work, as long as we can have a connection to each worker thread -- I
need to look closer at the relationship between renderer process and worker
threads to see exactly how to do it. If there are multiple service workers on a
renderer, then we'll need to maintain a connection to each, and look them up by
thread_id (or some other id).

[jkarlin, 2015/06/24 14:38:09]

Not sure I'm entirely following this. I think you guys are suggesting that we
move the mojo::InterfaceRequest to the appropriate thread before binding, right?
If so, that sgtm. 

[iclelland, 2015/06/24 14:42:05]

Right -- so in this case, we're moving *both* endpoints of the original
connection -- in the browser, we move it from UI to IO, and in the renderer,
from the main thread to the worker. Then the browser IO thread can communicate
directly with the worker.

+// be sent back over the mojo message channel.
+class CONTENT_EXPORT BackgroundSyncClientImpl
+    : public NON_EXPORTED_BASE(BackgroundSyncServiceClient) {
+ public:
+  static void Create(
+      const scoped_refptr<base::SingleThreadTaskRunner>&
+          main_thread_task_runner,
+      mojo::InterfaceRequest<BackgroundSyncServiceClient> request);
+
+  ~BackgroundSyncClientImpl() override;
+
+ private:
+  using SyncCallback = mojo::Callback<void(ServiceWorkerEventStatus)>;
+  explicit BackgroundSyncClientImpl(
+      const scoped_refptr<base::SingleThreadTaskRunner>&
+          main_thread_task_runner,
+      mojo::InterfaceRequest<BackgroundSyncServiceClient> request);
+
+  // BackgroundSyncClient methods:
+  void Sync(content::SyncRegistrationPtr registration,
+            int thread_id,
+            const SyncCallback& callback) override;
+
+  static void DispatchSyncOnWorkerThread(
+      const scoped_refptr<base::SingleThreadTaskRunner>&
+          main_thread_task_runner,
+      content::SyncRegistrationPtr event,
+      const SyncCallback& callback);
+  static void OnSyncCompleteOnWorkerThread(
+      const scoped_refptr<base::SingleThreadTaskRunner>&
+          main_thread_task_runner,
+      const SyncCallback& callback,
+      ServiceWorkerEventStatus status);
+  static void OnSyncCompleteOnMainThread(const SyncCallback& callback,
+                                         ServiceWorkerEventStatus status);
+
+  mojo::StrongBinding<BackgroundSyncServiceClient> binding_;
+
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
+
+  base::WeakPtrFactory<BackgroundSyncClientImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(BackgroundSyncClientImpl);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_BACKGROUND_SYNC_BACKGROUND_SYNC_CLIENT_IMPL_H_