mash: Move directly linked NewWindowDelegate to mojom::NewWindowClient.

chrome/browser/chromeos/chrome_interface_factory.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 "chrome/browser/chromeos/chrome_interface_factory.h"
 
 #include <memory>
 
 #include "ash/common/mojo_interface_factory.h"
+#include "ash/public/interfaces/new_window.mojom.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/ash/app_list/app_list_presenter_service.h"
 #include "chrome/browser/ui/ash/ash_util.h"
+#include "chrome/browser/ui/ash/chrome_new_window_client.h"
 #include "chrome/browser/ui/ash/keyboard_ui_service.h"
 #include "chrome/browser/ui/ash/system_tray_client.h"
 #include "chrome/browser/ui/ash/volume_controller_chromeos.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "content/public/common/service_manager_connection.h"
 #include "mash/public/interfaces/launchable.mojom.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/service_manager/public/cpp/connection.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
@@ skipping 77 matching lines @@
     keyboard_bindings_.AddBinding(keyboard_ui_service_.get(),
                                   std::move(request));
   }
 
   void BindRequest(mash::mojom::LaunchableRequest request) {
     if (!launchable_)
       launchable_ = base::MakeUnique<ChromeLaunchable>();
     launchable_->ProcessRequest(std::move(request));
   }
 
+  void BindRequest(ash::mojom::NewWindowClientRequest request) {
+    if (!new_window_client_)
+      new_window_client_.reset(new ChromeNewWindowClient);
+    new_window_client_bindings_.AddBinding(new_window_client_.get(),
+                                           std::move(request));
+  }
+
   void BindRequest(ash::mojom::SystemTrayClientRequest request) {
     system_tray_client_bindings_.AddBinding(SystemTrayClient::Get(),
                                             std::move(request));
   }
 
   void BindRequest(ash::mojom::WallpaperManagerRequest request) {
     WallpaperManager::Get()->BindRequest(std::move(request));
   }
 
   void BindRequest(ash::mojom::VolumeControllerRequest request) {
     if (!volume_controller_)
       volume_controller_ = base::MakeUnique<VolumeController>();
     volume_controller_->BindRequest(std::move(request));
   }
 
   void BindRequest(app_list::mojom::AppListPresenterRequest request) {
     if (!app_list_presenter_service_)
       app_list_presenter_service_ = base::MakeUnique<AppListPresenterService>();
     app_list_presenter_bindings_.AddBinding(app_list_presenter_service_.get(),
                                             std::move(request));
   }
 
   static base::LazyInstance<std::unique_ptr<FactoryImpl>>::Leaky factory_;
 
   std::unique_ptr<KeyboardUIService> keyboard_ui_service_;
   mojo::BindingSet<keyboard::mojom::Keyboard> keyboard_bindings_;
   std::unique_ptr<ChromeLaunchable> launchable_;
+  std::unique_ptr<ChromeNewWindowClient> new_window_client_;
+  mojo::BindingSet<ash::mojom::NewWindowClient> new_window_client_bindings_;
   mojo::BindingSet<ash::mojom::SystemTrayClient> system_tray_client_bindings_;
   std::unique_ptr<VolumeController> volume_controller_;
   std::unique_ptr<AppListPresenterService> app_list_presenter_service_;
   mojo::BindingSet<app_list::mojom::AppListPresenter>
       app_list_presenter_bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(FactoryImpl);
 };
 
 base::LazyInstance<std::unique_ptr<FactoryImpl>>::Leaky FactoryImpl::factory_ =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 ChromeInterfaceFactory::ChromeInterfaceFactory()
     : main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
 ChromeInterfaceFactory::~ChromeInterfaceFactory() {}
 
 bool ChromeInterfaceFactory::OnConnect(
     const service_manager::Identity& remote_identity,
     service_manager::InterfaceRegistry* registry,
     service_manager::Connector* connector) {
   FactoryImpl::AddFactory<keyboard::mojom::Keyboard>(registry,
                                                      main_thread_task_runner_);
   FactoryImpl::AddFactory<mash::mojom::Launchable>(registry,
                                                    main_thread_task_runner_);
+  FactoryImpl::AddFactory<ash::mojom::NewWindowClient>(
+      registry, main_thread_task_runner_);
   FactoryImpl::AddFactory<ash::mojom::SystemTrayClient>(
       registry, main_thread_task_runner_);
   FactoryImpl::AddFactory<ash::mojom::VolumeController>(
       registry, main_thread_task_runner_);
   FactoryImpl::AddFactory<ash::mojom::WallpaperManager>(
       registry, main_thread_task_runner_);
   FactoryImpl::AddFactory<app_list::mojom::AppListPresenter>(
       registry, main_thread_task_runner_);
 
   // In classic ash, the browser process provides ash services to itself.
   if (!chrome::IsRunningInMash()) {
     ash::mojo_interface_factory::RegisterInterfaces(registry,
                                                     main_thread_task_runner_);
   }
 
   return true;
 }
 
 }  // namespace chromeos