Add GamepadService, owns 1 gamepad bg thread

content/browser/gamepad/gamepad_service.h

+// Copyright (c) 2011 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.
+
+// Owns the GamepadProvider (the background polling thread) and keeps track of
+// the number of renderers currently using the data (and pausing the provider
+// when not in use).
+
+#ifndef CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_H
+#define CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_H
+
+#include "base/basictypes.h"
+#include "base/memory/singleton.h"
+#include "base/shared_memory.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+
+namespace content {
+
+class GamepadDataFetcher;
+class GamepadProvider;
+class RenderProcessHost;
+
+class GamepadService : public NotificationObserver,
+                       public base::RefCountedThreadSafe<GamepadService> {

[jam, 2011/12/01 20:07:31]

nit: it's weird that this is both a singelton and refcounted. if you're doing
this just so you can do PostTasks, you can add

DISABLE_RUNNABLE_METHOD_REFCOUNT(GamepadService);

at the bottom of the file

[scottmg, 2011/12/01 22:05:32]

Ah, yes, that's why I did that craziness. After poking around a bit, it seems
it's changed since the new Bind() stuff was added. Rather than that macro, it
looks like the thing to do now is to wrap the object pointer in the Bind call
with Unretained().

+ public:
+  // Returns the GamepadService singleton.
+  static GamepadService* GetInstance();
+
+  // Called on IO thread from a renderer host. Increments the number of users
+  // of the provider. The Provider is running when there's > 0 users, and is
+  // paused when the count drops to 0. There is no stop, the gamepad service
+  // registers with the RPH to be notified when the associated renderer closes
+  // (or crashes).
+  void Start(GamepadDataFetcher* fetcher,
+             RenderProcessHost* associated_rph);
+
+  base::SharedMemoryHandle GetSharedMemoryHandle(base::ProcessHandle handle);
+
+  // NotificationObserver overrides:

[jam, 2011/12/01 20:07:31]

nit: can be private

[scottmg, 2011/12/01 22:05:32]

Done.

+  virtual void Observe(int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE;
+
+ private:
+  friend struct DefaultSingletonTraits<GamepadService>;
+  friend class base::RefCountedThreadSafe<GamepadService>;
+  GamepadService();
+  virtual ~GamepadService();
+
+  // Called when a renderer that Start'd us is closed/crashes.
+  void Stop();
+
+  // Run on UI thread to receive notifications of renderer closes.
+  void RegisterForCloseNotification(RenderProcessHost* rph);
+
+  // A registrar for listening notifications. Used to listen for when an
+  // associated renderer has gone away (possibly crashed). We don't trust
+  // the renderers to send a stop message because of the possibility of
+  // crashing.
+  NotificationRegistrar registrar_;
+
+  int num_readers_;
+  scoped_refptr<GamepadProvider> provider_;
+
+  static GamepadService* instance_;
+
+  DISALLOW_COPY_AND_ASSIGN(GamepadService);
+};
+
+} // namespace content
+
+#endif // CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_H