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

services/ui/service.h

 // 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.
 
 #ifndef SERVICES_UI_SERVICE_H_
 #define SERVICES_UI_SERVICE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 35 matching lines @@
 class ScreenManager;
 }
 
 namespace service_manager {
 class Connector;
 class Identity;
 }
 
 namespace ui {
 
+class ImageCursors;
 class InputDeviceController;
 class PlatformEventSource;
 
 namespace ws {
 class WindowServer;
 }
 
 class Service : public service_manager::Service,
                 public ws::WindowServerDelegate {
  public:
-  Service();
+  // |resource_runner| is the task runner for the thread which can be used to
+  // load resources. Used when UI Service run inside a Window Manager's
+  // process (and so the resources need to be loaded on the WM's thread).
+  // When UI Service is run in a separate process, |resource_runner|
+  // should be null, and resources are loaded on the UI Service's thread.
+  // |image_cursors_weak_ptr| is also only used when the UI service runs
+  // in-process. It can only be dereferenced on |resource_runner|.
+  Service(scoped_refptr<base::SingleThreadTaskRunner> resource_runner,

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

optional: Create a structure named InProcessConfig (or something similar) that
contains the two members. This way it's a bit clearer if passed null the ui
service is not run in process.

[mfomitchev, 2017/07/11 21:47:00]

Done.

+          base::WeakPtr<ui::ImageCursors> image_cursors_weak_ptr);
   ~Service() override;
 
  private:
   // Holds InterfaceRequests received before the first WindowTreeHost Display
   // has been established.
   struct PendingRequest;
   struct UserState;
 
   using UserIdToUserState = std::map<ws::UserId, std::unique_ptr<UserState>>;
 
+  bool in_process() { return in_process_; }

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

bool in_process() const
optional: prefix member and function with 'is_' as 'in process' reads like a
verb.

[mfomitchev, 2017/07/11 21:46:59]

Done.

+
   // Attempts to initialize the resource bundle. Returns true if successful,
   // otherwise false if resources cannot be loaded.
   bool InitializeResources(service_manager::Connector* connector);
 
   // Returns the user specific state for the user id of |remote_identity|.
   // Service owns the return value.
   // TODO(sky): if we allow removal of user ids then we need to close anything
   // associated with the user (all incoming pipes...) on removal.
   UserState* GetUserState(const service_manager::Identity& remote_identity);
 
   void AddUserIfNecessary(const service_manager::Identity& remote_identity);
 
   // service_manager::Service:
   void OnStart() override;
   void OnBindInterface(const service_manager::BindSourceInfo& source_info,
                        const std::string& interface_name,
                        mojo::ScopedMessagePipeHandle interface_pipe) override;
 
   // WindowServerDelegate:
   void StartDisplayInit() override;
   void OnFirstDisplayReady() override;
   void OnNoMoreDisplays() override;
   bool IsTestConfig() const override;
   void OnWillCreateTreeForWindowManager(
       bool automatically_create_display_roots) override;
+  scoped_refptr<base::SingleThreadTaskRunner>& GetResourceRunner() override;
+  base::WeakPtr<ui::ImageCursors> GetImageCursorsWeakPtr() override;
 
   void BindAccessibilityManagerRequest(
       const service_manager::BindSourceInfo& source_info,
       mojom::AccessibilityManagerRequest request);
 
   void BindClipboardRequest(const service_manager::BindSourceInfo& source_info,
                             mojom::ClipboardRequest request);
 
   void BindDisplayManagerRequest(
       const service_manager::BindSourceInfo& source_info,
@@ skipping 41 matching lines @@
   std::unique_ptr<ui::PlatformEventSource> event_source_;
   using PendingRequests = std::vector<std::unique_ptr<PendingRequest>>;
   PendingRequests pending_requests_;
 
   UserIdToUserState user_id_to_user_state_;
 
   // Provides input-device information via Mojo IPC. Registers Mojo interfaces
   // and must outlive |registry_|.
   InputDeviceServer input_device_server_;
 
+  // True if the UI Service runs inside WM's process, false if it runs inside
+  // its own process.
+  bool in_process_;
+
+  // Can be used to access resources. Will be null until the service is started

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

Please group in-process related state into a structure to make it clear what is
needed when in process and what isn't. This structure would be difference than
the one I recommended above.

[mfomitchev, 2017/07/11 21:47:00]

Created ThreadedImageCursorsFactory(Impl). I think it makes some other things
cleaner as well.

+  // if the UI Service doesn't run in WM's process.
+  scoped_refptr<base::SingleThreadTaskRunner> resource_runner_;
+
+  // Used when UI Service runs in-process, and can only be de-referenced on
+  // |resource_runner_|. When UI Service doesn't run in-process, this points to
+  // |image_cursors_| (and should be de-referenced on UI Serivice's thread).
+  base::WeakPtr<ui::ImageCursors> image_cursors_weak_ptr_;
+
+  // Used when UI Service doesn't run in-process.
+  std::unique_ptr<ui::ImageCursors> image_cursors_;
+
   bool test_config_;
 #if defined(USE_OZONE)
   std::unique_ptr<gfx::ClientNativePixmapFactory> client_native_pixmap_factory_;
 #if defined(OS_CHROMEOS)
   std::unique_ptr<InputDeviceController> input_device_controller_;
 #endif
 #endif
 
   // Manages display hardware and handles display management. May register Mojo
   // interfaces and must outlive |registry_|.
   std::unique_ptr<display::ScreenManager> screen_manager_;
 
   IMERegistrarImpl ime_registrar_;
   IMEDriverBridge ime_driver_;
 
   std::unique_ptr<discardable_memory::DiscardableSharedMemoryManager>
       discardable_shared_memory_manager_;
 
   service_manager::BinderRegistry registry_;
 
   // Set to true in StartDisplayInit().
   bool is_gpu_ready_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(Service);
 };
 
 }  // namespace ui
 
 #endif  // SERVICES_UI_SERVICE_H_