Creates mus test helper class

components/mus/public/cpp/lib/window_tree_client_impl.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 "components/mus/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 1014 matching lines @@
     DCHECK(window_manager_delegate_);
     gfx::Rect bounds = transit_bounds.To<gfx::Rect>();
     result = window_manager_delegate_->OnWmSetBounds(window, &bounds);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
       result = bounds == transit_bounds.To<gfx::Rect>();
       window->SetBounds(bounds);
     }
   }
-  window_manager_internal_client_->WmResponse(change_id, result);
+  if (window_manager_internal_client_)
+    window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClientImpl::WmSetProperty(uint32_t change_id,
                                          Id window_id,
                                          const mojo::String& name,
                                          mojo::Array<uint8_t> transit_data) {
   Window* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     DCHECK(window_manager_delegate_);
     std::unique_ptr<std::vector<uint8_t>> data;
     if (!transit_data.is_null()) {
       data.reset(
           new std::vector<uint8_t>(transit_data.To<std::vector<uint8_t>>()));
     }
     result = window_manager_delegate_->OnWmSetProperty(window, name, &data);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
       window->SetSharedPropertyInternal(name, data.get());
     }
   }
-  window_manager_internal_client_->WmResponse(change_id, result);
+  if (window_manager_internal_client_)
+    window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClientImpl::WmCreateTopLevelWindow(
     uint32_t change_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   std::map<std::string, std::vector<uint8_t>> properties =
       transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
   Window* window =
       window_manager_delegate_->OnWmCreateTopLevelWindow(&properties);
-  window_manager_internal_client_->OnWmCreatedTopLevelWindow(change_id,
-                                                             server_id(window));
+  if (window_manager_internal_client_) {
+    window_manager_internal_client_->OnWmCreatedTopLevelWindow(
+        change_id, server_id(window));
+  }
 }
 
 void WindowTreeClientImpl::OnAccelerator(uint32_t id, mojom::EventPtr event) {
   window_manager_delegate_->OnAccelerator(
       id, *event.To<std::unique_ptr<ui::Event>>().get());
 }
 
 void WindowTreeClientImpl::SetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
-  window_manager_internal_client_->WmSetFrameDecorationValues(
-      std::move(values));
+  if (window_manager_internal_client_) {
+    window_manager_internal_client_->WmSetFrameDecorationValues(
+        std::move(values));
+  }
 }
 
 void WindowTreeClientImpl::SetNonClientCursor(Window* window,
                                               mus::mojom::Cursor cursor_id) {
   window_manager_internal_client_->WmSetNonClientCursor(server_id(window),
                                                         cursor_id);
 }
 
 void WindowTreeClientImpl::AddAccelerator(
     uint32_t id,
     mojom::EventMatcherPtr event_matcher,
     const base::Callback<void(bool)>& callback) {
-  window_manager_internal_client_->AddAccelerator(id, std::move(event_matcher),
-                                                  callback);
+  if (window_manager_internal_client_) {
+    window_manager_internal_client_->AddAccelerator(
+        id, std::move(event_matcher), callback);
+  }
 }
 
 void WindowTreeClientImpl::RemoveAccelerator(uint32_t id) {
-  window_manager_internal_client_->RemoveAccelerator(id);
+  if (window_manager_internal_client_) {
+    window_manager_internal_client_->RemoveAccelerator(id);
+  }
 }
 
 void WindowTreeClientImpl::AddActivationParent(Window* window) {
-  window_manager_internal_client_->AddActivationParent(server_id(window));
+  if (window_manager_internal_client_)
+    window_manager_internal_client_->AddActivationParent(server_id(window));
 }
 
 void WindowTreeClientImpl::RemoveActivationParent(Window* window) {
-  window_manager_internal_client_->RemoveActivationParent(server_id(window));
+  if (window_manager_internal_client_)
+    window_manager_internal_client_->RemoveActivationParent(server_id(window));
 }
 
 void WindowTreeClientImpl::ActivateNextWindow() {
-  window_manager_internal_client_->ActivateNextWindow();
+  if (window_manager_internal_client_)
+    window_manager_internal_client_->ActivateNextWindow();
 }
 
 void WindowTreeClientImpl::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
-  window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
-      server_id(window), offset.x(), offset.y(), mojo::Insets::From(hit_area));
+  if (window_manager_internal_client_) {
+    window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
+        server_id(window), offset.x(), offset.y(),
+        mojo::Insets::From(hit_area));
+  }
 }
 
 }  // namespace mus