views/mus: Have explicit ownership of views::WindowManagerConnection.

ui/views/mus/window_manager_connection.cc

 // 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.
 
 #include "ui/views/mus/window_manager_connection.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/threading/thread_local.h"
@@ skipping 17 matching lines @@
 using WindowManagerConnectionPtr =
     base::ThreadLocalPointer<views::WindowManagerConnection>;
 
 // Env is thread local so that aura may be used on multiple threads.
 base::LazyInstance<WindowManagerConnectionPtr>::Leaky lazy_tls_ptr =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static
-void WindowManagerConnection::Create(shell::Connector* connector,
-                                     const shell::Identity& identity) {
+std::unique_ptr<WindowManagerConnection> WindowManagerConnection::Create(
+    shell::Connector* connector,
+    const shell::Identity& identity) {
   DCHECK(!lazy_tls_ptr.Pointer()->Get());
-  lazy_tls_ptr.Pointer()->Set(new WindowManagerConnection(connector, identity));
+  WindowManagerConnection* connection =
+      new WindowManagerConnection(connector, identity);
+  DCHECK(lazy_tls_ptr.Pointer()->Get());
+  return base::WrapUnique(connection);
 }
 
 // static
 WindowManagerConnection* WindowManagerConnection::Get() {
   WindowManagerConnection* connection = lazy_tls_ptr.Pointer()->Get();
   DCHECK(connection);
   return connection;
 }
 
 // static
 bool WindowManagerConnection::Exists() {
   return !!lazy_tls_ptr.Pointer()->Get();
 }
 
-// static
-void WindowManagerConnection::Reset() {
-  delete Get();
-  lazy_tls_ptr.Pointer()->Set(nullptr);
-}
-
 mus::Window* WindowManagerConnection::NewWindow(
     const std::map<std::string, std::vector<uint8_t>>& properties) {
   return window_tree_connection_->NewTopLevelWindow(&properties);
 }
 
 NativeWidget* WindowManagerConnection::CreateNativeWidgetMus(
     const std::map<std::string, std::vector<uint8_t>>& props,
     const Widget::InitParams& init_params,
     internal::NativeWidgetDelegate* delegate) {
   std::map<std::string, std::vector<uint8_t>> properties = props;
@@ skipping 23 matching lines @@
     // Last PointerWatcher removed, stop the event observer.
     window_tree_connection_->SetEventObserver(nullptr);
   }
 }
 
 WindowManagerConnection::WindowManagerConnection(
     shell::Connector* connector,
     const shell::Identity& identity)
     : connector_(connector),
       identity_(identity),
-      window_tree_connection_(nullptr) {
+      created_device_data_manager_(false) {
+  lazy_tls_ptr.Pointer()->Set(this);
   window_tree_connection_.reset(
       mus::WindowTreeConnection::Create(this, connector_));
 
   screen_.reset(new ScreenMus(this));
   screen_->Init(connector);
 
-  // TODO(sad): We should have a DeviceDataManager implementation that talks to
-  // a mojo service to learn about the input-devices on the system.
-  // http://crbug.com/601981
-  ui::DeviceDataManager::CreateInstance();
+  if (!ui::DeviceDataManager::HasInstance()) {
+    // TODO(sad): We should have a DeviceDataManager implementation that talks
+    // to a mojo service to learn about the input-devices on the system.
+    // http://crbug.com/601981
+    ui::DeviceDataManager::CreateInstance();
+    created_device_data_manager_ = true;
+  }
 
   ViewsDelegate::GetInstance()->set_native_widget_factory(base::Bind(
       &WindowManagerConnection::CreateNativeWidgetMus,
       base::Unretained(this),
       std::map<std::string, std::vector<uint8_t>>()));
 }
 
 WindowManagerConnection::~WindowManagerConnection() {
   // ~WindowTreeConnection calls back to us (we're the WindowTreeDelegate),
   // destroy it while we are still valid.
   window_tree_connection_.reset();
-
-  ui::DeviceDataManager::DeleteInstance();
+  if (created_device_data_manager_)
+    ui::DeviceDataManager::DeleteInstance();
+  lazy_tls_ptr.Pointer()->Set(nullptr);
 }
 
 bool WindowManagerConnection::HasPointerWatcher() {
   // Check to see if we really have any observers left. This doesn't use
   // base::ObserverList<>::might_have_observers() because that returns true
   // during iteration over the list even when the last observer is removed.
   base::ObserverList<PointerWatcher>::Iterator iterator(&pointer_watchers_);
   return !!iterator.GetNext();
 }
 
@@ skipping 30 matching lines @@
 void WindowManagerConnection::OnWindowManagerFrameValuesChanged() {
   if (window_tree_connection_)
     NativeWidgetMus::NotifyFrameChanged(window_tree_connection_.get());
 }
 
 gfx::Point WindowManagerConnection::GetCursorScreenPoint() {
   return window_tree_connection_->GetCursorScreenPoint();
 }
 
 }  // namespace views