views/mus: Recreate WindowManagerConnection for each test.

ui/views/mus/views_mus_test_suite.cc

 // Copyright 2016 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/views_mus_test_suite.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 24 matching lines @@
  public:
   DefaultShellClient() {}
   ~DefaultShellClient() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultShellClient);
 };
 
 class PlatformTestHelperMus : public PlatformTestHelper {
  public:
-  PlatformTestHelperMus() {
-    ViewsDelegate::GetInstance()->set_native_widget_factory(base::Bind(
-        &WindowManagerConnection::CreateNativeWidgetMus,
-        base::Unretained(WindowManagerConnection::Get()),
-        std::map<std::string, std::vector<uint8_t>>()));
+  PlatformTestHelperMus(shell::Connector* connector,
+                        const shell::Identity& identity) {
+    // It is necessary to recreate the WindowManagerConnection for each test,
+    // since a new MessageLoop is created for each test.
+    WindowManagerConnection::Create(connector, identity);
   }
-  ~PlatformTestHelperMus() override {}
+  ~PlatformTestHelperMus() override { WindowManagerConnection::Reset(); }

[sky, 2016/05/31 18:01:27]

Can you make ~WindowManagerConnection also unset itself as the native widget
factory? At a minimum WindowManagerConnection should use a weakptr.

[sadrul, 2016/05/31 18:08:15]

Updated ~WMC to unset the native-widget factory.

 
  private:
   DISALLOW_COPY_AND_ASSIGN(PlatformTestHelperMus);
 };
 
 std::unique_ptr<PlatformTestHelper> CreatePlatformTestHelper(
-    shell::Connector* connector,
-    const shell::Identity& identity) {
-  if (!WindowManagerConnection::Exists())
-    WindowManagerConnection::Create(connector, identity);
-  return base::WrapUnique(new PlatformTestHelperMus);
+    const shell::Identity& identity,
+    const base::Callback<shell::Connector*(void)>& callback) {
+  return base::WrapUnique(new PlatformTestHelperMus(callback.Run(), identity));
 }
 
 }  // namespace
 
 class ShellConnection {
  public:
   ShellConnection() : thread_("Persistent shell connections") {
     base::WaitableEvent wait(false, false);
     base::Thread::Options options;
     thread_.StartWithOptions(options);
     thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&ShellConnection::SetUpConnections,
                               base::Unretained(this), &wait));
     wait.Wait();
 
     // WindowManagerConnection cannot be created from here yet, although the
     // connector and identity are available at this point. This is because
     // WindowManagerConnection needs a ViewsDelegate and a MessageLoop to have
     // been installed first. So delay the creation until the necessary
     // dependencies have been met.
     PlatformTestHelper::set_factory(base::Bind(
-        &CreatePlatformTestHelper, shell_connector_.get(), shell_identity_));
+        &CreatePlatformTestHelper, shell_identity_,
+        base::Bind(&ShellConnection::GetConnector, base::Unretained(this))));
   }
 
   ~ShellConnection() {
     if (views::WindowManagerConnection::Exists())
       views::WindowManagerConnection::Reset();
     base::WaitableEvent wait(false, false);
     thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&ShellConnection::TearDownConnections,
                               base::Unretained(this), &wait));
     wait.Wait();
   }
 
  private:
+  shell::Connector* GetConnector() {
+    shell_connector_.reset();
+    base::WaitableEvent wait(false, false);
+    thread_.task_runner()->PostTask(FROM_HERE,
+                                    base::Bind(&ShellConnection::CloneConnector,
+                                               base::Unretained(this), &wait));
+    wait.Wait();
+    DCHECK(shell_connector_);
+    return shell_connector_.get();
+  }
+
+  void CloneConnector(base::WaitableEvent* wait) {
+    shell_connector_ = shell_connection_->connector()->Clone();
+    wait->Signal();
+  }
+
   void SetUpConnections(base::WaitableEvent* wait) {
     background_shell_.reset(new shell::BackgroundShell);
     background_shell_->Init(nullptr);
     shell_client_.reset(new DefaultShellClient);
     shell_connection_.reset(new shell::ShellConnection(
         shell_client_.get(),
         background_shell_->CreateShellClientRequest(GetTestName())));
 
     // ui/views/mus requires a WindowManager running, so launch test_wm.
     shell::Connector* connector = shell_connection_->connector();
@@ skipping 42 matching lines @@
   ViewsTestSuite::Initialize();
   shell_connections_.reset(new ShellConnection);
 }
 
 void ViewsMusTestSuite::Shutdown() {
   shell_connections_.reset();
   ViewsTestSuite::Shutdown();
 }
 
 }  // namespace views