Adds a way to associate key/value pairs with the environment

mojo/common/handle_watcher.cc

 // Copyright 2013 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 "mojo/common/handle_watcher.h"
 
 #include <map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
-#include "base/lazy_instance.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
+#include "mojo/common/environment_data.h"
 #include "mojo/common/message_pump_mojo.h"
 #include "mojo/common/message_pump_mojo_handler.h"
 #include "mojo/common/time_helper.h"
 
 namespace mojo {
 namespace common {
 
 typedef int WatcherID;
 
 namespace {
 
 const char kWatcherThreadName[] = "handle-watcher-thread";
 
+const char kWatcherThreadManagerKey[] = "watcher-thread-manager";
+
 // TODO(sky): this should be unnecessary once MessageLoop has been refactored.
 MessagePumpMojo* message_pump_mojo = NULL;
 
 scoped_ptr<base::MessagePump> CreateMessagePumpMojo() {
   message_pump_mojo = new MessagePumpMojo;
   return scoped_ptr<base::MessagePump>(message_pump_mojo).Pass();
 }
 
 base::TimeTicks MojoDeadlineToTimeTicks(MojoDeadline deadline) {
   return deadline == MOJO_DEADLINE_INDEFINITE ? base::TimeTicks() :
@@ skipping 106 matching lines @@
 void WatcherBackend::OnHandleError(const Handle& handle, MojoResult result) {
   RemoveAndNotify(handle, result);
 }
 
 // WatcherThreadManager --------------------------------------------------------
 
 // WatcherThreadManager manages the background thread that listens for handles
 // to be ready. All requests are handled by WatcherBackend.
 class WatcherThreadManager {
  public:
+  ~WatcherThreadManager();
+
   // Returns the shared instance.
   static WatcherThreadManager* GetInstance();
 
   // Starts watching the requested handle. Returns a unique ID that is used to
   // stop watching the handle. When the handle is ready |callback| is notified
   // on the thread StartWatching() was invoked on.
   // This may be invoked on any thread.
   WatcherID StartWatching(const Handle& handle,
                           MojoWaitFlags wait_flags,
                           base::TimeTicks deadline,
                           const base::Callback<void(MojoResult)>& callback);
 
   // Stops watching a handle.
   // This may be invoked on any thread.
   void StopWatching(WatcherID watcher_id);
 
  private:
-  friend struct base::DefaultLazyInstanceTraits<WatcherThreadManager>;
-
   WatcherThreadManager();
-  ~WatcherThreadManager();
 
   base::Thread thread_;
 
   base::AtomicSequenceNumber watcher_id_generator_;
 
   WatcherBackend backend_;
 
   DISALLOW_COPY_AND_ASSIGN(WatcherThreadManager);
 };
 
+struct WatcherThreadManagerData : EnvironmentData::Data {
+  scoped_ptr<WatcherThreadManager> thread_manager;
+};
+
+WatcherThreadManager::~WatcherThreadManager() {
+  thread_.Stop();
+}
+
 WatcherThreadManager* WatcherThreadManager::GetInstance() {
-  static base::LazyInstance<WatcherThreadManager> instance =
-      LAZY_INSTANCE_INITIALIZER;
-  return &instance.Get();
+  WatcherThreadManagerData* data = static_cast<WatcherThreadManagerData*>(

[darin (slow to review), 2014/03/31 23:21:55]

it looks like you have to worry about multiple threads racing to call
WatcherThreadManager::GetInstance() here, and this code does not protect against
that case.

[sky, 2014/03/31 23:54:40]

Done.

+      EnvironmentData::GetInstance()->GetData(kWatcherThreadManagerKey));
+  if (!data) {
+    data = new WatcherThreadManagerData;
+    data->thread_manager.reset(new WatcherThreadManager);
+    EnvironmentData::GetInstance()->SetData(
+        kWatcherThreadManagerKey,
+        scoped_ptr<EnvironmentData::Data>(data));
+  }
+  return data->thread_manager.get();
 }
 
 WatcherID WatcherThreadManager::StartWatching(
     const Handle& handle,
     MojoWaitFlags wait_flags,
     base::TimeTicks deadline,
     const base::Callback<void(MojoResult)>& callback) {
   WatchData data;
   data.id = watcher_id_generator_.GetNext();
   data.handle = handle;
@@ skipping 21 matching lines @@
                  watcher_id));
 }
 
 WatcherThreadManager::WatcherThreadManager()
     : thread_(kWatcherThreadName) {
   base::Thread::Options thread_options;
   thread_options.message_pump_factory = base::Bind(&CreateMessagePumpMojo);
   thread_.StartWithOptions(thread_options);
 }
 
-WatcherThreadManager::~WatcherThreadManager() {
-  thread_.Stop();
-}
-
 }  // namespace
 
 // HandleWatcher::StartState ---------------------------------------------------
 
 // Contains the information passed to Start().
 struct HandleWatcher::StartState {
   explicit StartState(HandleWatcher* watcher) : weak_factory(watcher) {
   }
 
   ~StartState() {
@@ skipping 54 matching lines @@
 void HandleWatcher::OnHandleReady(MojoResult result) {
   DCHECK(start_state_.get());
   scoped_ptr<StartState> old_state(start_state_.Pass());
   old_state->callback.Run(result);
 
   // NOTE: We may have been deleted during callback execution.
 }
 
 }  // namespace common
 }  // namespace mojo