Move Mus into chrome's process when running with --mus.

ui/events/platform/platform_event_source.cc

 // Copyright 2014 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 "ui/events/platform/platform_event_source.h"
 
 #include <algorithm>
 
+#include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/threading/thread_local.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_observer.h"
 #include "ui/events/platform/scoped_event_dispatcher.h"
 
 namespace ui {
+namespace {
 
-// static
-PlatformEventSource* PlatformEventSource::instance_ = NULL;
+// PlatformEventSource singleton is thread local so that different instances
+// can be used on different threads (e.g. WindowServer thread vs. browser UI
+// thread).
+base::LazyInstance<base::ThreadLocalPointer<PlatformEventSource>>::Leaky

[sky, 2017/06/27 19:58:57]

Same comment here. What code in chrome/ash is making use of this?

[mfomitchev, 2017/06/27 22:14:55]

Aura does it:
https://cs.chromium.org/chromium/src/ui/aura/env.cc?type=cs&q=PlatformEventSo...

[sky, 2017/06/28 00:22:02]

That's only for the LOCAL case. How are we triggering the LOCAL case for
mus/mash?

[mfomitchev, 2017/06/28 15:56:32]

Oops, you are right, this isn't needed. I misread the code. Will revert this
back to the way it was.

[mfomitchev, 2017/07/12 20:37:13]

I remember now there was another reason I made this TLS. If it's not TLS, then
Ash can execute code on Mus thread by adding |PlatformEventObserver|s, which
doesn't seem good. This also leads to a concrete issue: 

ui::PlatformEventSource::DispatchEvent ->
ui::UserActivityDetector::DidProcessEvent ->
chromeos::SessionLengthLimiter::OnUserActivity ->
SequenceChecker DCHECK in BrowserProcessImple::local_state()

Do you think it would be okay to make PlatformEventObserver thread-local?

+    lazy_tls_ptr = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
 
 PlatformEventSource::PlatformEventSource()
     : overridden_dispatcher_(NULL),
       overridden_dispatcher_restored_(false) {
-  CHECK(!instance_) << "Only one platform event source can be created.";
-  instance_ = this;
+  CHECK(!lazy_tls_ptr.Pointer()->Get())
+      << "Only one platform event source can be created per thread.";
+  lazy_tls_ptr.Pointer()->Set(this);
 }
 
 PlatformEventSource::~PlatformEventSource() {
-  CHECK_EQ(this, instance_);
-  instance_ = NULL;
+  CHECK_EQ(this, lazy_tls_ptr.Pointer()->Get());
+  lazy_tls_ptr.Pointer()->Set(nullptr);
 }
 
-PlatformEventSource* PlatformEventSource::GetInstance() { return instance_; }
+PlatformEventSource* PlatformEventSource::GetInstance() {
+  return lazy_tls_ptr.Pointer()->Get();
+}
 
 void PlatformEventSource::AddPlatformEventDispatcher(
     PlatformEventDispatcher* dispatcher) {
   CHECK(dispatcher);
   dispatchers_.AddObserver(dispatcher);
   OnDispatcherListChanged();
 }
 
 void PlatformEventSource::RemovePlatformEventDispatcher(
     PlatformEventDispatcher* dispatcher) {
@@ skipping 58 matching lines @@
 
 void PlatformEventSource::OnDispatcherListChanged() {
 }
 
 void PlatformEventSource::OnOverriddenDispatcherRestored() {
   CHECK(overridden_dispatcher_);
   overridden_dispatcher_restored_ = true;
 }
 
 }  // namespace ui