// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_APP_SHIM_APP_SHIM_CONTROLLER_H_
#define CHROME_APP_SHIM_APP_SHIM_CONTROLLER_H_
#include <vector>
#import <AppKit/AppKit.h>
#include "base/files/file_path.h"
#include "chrome/common/mac/app_shim.mojom.h"
#include "chrome/services/mac_notifications/public/mojom/mac_notifications.mojom.h"
#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "mojo/public/cpp/platform/named_platform_channel.h"
#include "mojo/public/cpp/system/isolated_connection.h"
#include "url/gurl.h"
namespace apps {
class MachBootstrapAcceptorTest;
}
namespace display {
class ScopedNativeScreen;
}
namespace mac_notifications {
class MacNotificationServiceUN;
}
@class AppShimDelegate;
@class ProfileMenuTarget;
@class ApplicationDockMenuTarget;
@protocol RenderWidgetHostViewMacDelegate;
// The AppShimController is responsible for launching and maintaining the
// connection with the main Chrome process, and generally controls the lifetime
// of the app shim process.
class AppShimController
: public chrome::mojom::AppShim,
public mac_notifications::mojom::MacNotificationProvider {
public:
struct Params {
Params();
Params(const Params& other);
~Params();
// The full path of the user data dir.
base::FilePath user_data_dir;
// The relative path of the profile.
base::FilePath profile_dir;
std::string app_id;
std::u16string app_name;
GURL app_url;
// Task runner for the IO thread, only used to guarantee no race conditions
// when swapping out FeatureList instances in FinalizeFeatureState();
scoped_refptr<base::SequencedTaskRunner> io_thread_runner;
};
explicit AppShimController(const Params& params);
AppShimController(const AppShimController&) = delete;
AppShimController& operator=(const AppShimController&) = delete;
~AppShimController() override;
// Called early in process startup to temporarily initialize base::FeatureList
// and field trial state with a best guess of what the state should be. This
// gets state from the command line and/or a file in user_data_dir.
// FeatureList and field trials are later re-initialized in
// OnShimConnectedResponse, once communication with the correct chrome
// instance has been established.
static void PreInitFeatureState(const base::CommandLine& command_line);
// Called by OnShimConnectedResponse to finish setting up FeatureList and
// field trials for this process.
static void FinalizeFeatureState(
const variations::VariationsCommandLine& feature_state,
const scoped_refptr<base::SequencedTaskRunner>& io_thread_runner);
chrome::mojom::AppShimHost* host() const { return host_.get(); }
// Called by AppShimDelegate in response to receiving the notification
// -[NSApplicationDelegate applicationDidFinishLaunching:]. This kicks off
// the initialization process (connecting to Chrome, etc).
// `was_notification_action_launch` is set to true if this app shim was
// launched by the OS in response to the user interacting with a
// notification.
void OnAppFinishedLaunching(bool launched_by_notification_action);
// Called by AppShimDelegate in response a file being opened. If this occurs
// before OnDidFinishLaunching, then the argument is the files that triggered
// the launch of the app.
void OpenFiles(const std::vector<base::FilePath>& files);
// Called when a profile is selected from the profiles NSMenu.
void ProfileMenuItemSelected(uint32_t index);
// Called when a item is selected from the application dock menu.
void CommandFromDock(uint32_t index);
// Called when an item is selected from the application menu while no windows
// are shown.
void CommandDispatch(int command_id);
// Called by AppShimDelegate in response to an URL being opened. If this
// occurs before OnDidFinishLaunching, then the argument is the files that
// triggered the launch of the app.
void OpenUrls(const std::vector<GURL>& urls);
NSMenu* GetApplicationDockMenu();
// Called when the app is about to terminate.
void ApplicationWillTerminate();
// Returns the current MacNotificationService instances as a
// MacNotificationServiceUN, or nullptr if no notification service has been
// created yet, or if it is of the wrong type.
mac_notifications::MacNotificationServiceUN* notification_service_un();
private:
friend class TestShimClient;
friend class apps::MachBootstrapAcceptorTest;
// The state of initialization.
enum class InitState {
// Waiting for OnAppFinishedLaunching to be called.
kWaitingForAppToFinishLaunch,
// Waiting for PollForChromeReady to connect to the browser process.
kWaitingForChromeReady,
// Has sent OnShimConnected to the browser process, waiting for the
// response.
kHasSentOnShimConnected,
// Has received the OnShimConnected response from the browser,
// initialization is now complete.
kHasReceivedOnShimConnectedResponse,
};
// Init step 1 after OnAppFinishedLaunching. Find a running instance of Chrome
// to connect to, or launch Chrome if none is found. Returns true if a
// running instance was found and polling for readiness is possible.
bool FindOrLaunchChrome();
// Init step 2: Poll for the mach server exposed by Chrome's AppShimListener
// to be initialized. Once it has, proceed to SendBootstrapOnShimConnected.
// If |time_until_timeout| runs out, quit the app shim.
void PollForChromeReady(const base::TimeDelta& time_until_timeout);
// Init step 3: Reinterpret |endpoint| as a mojom::AppShimHostBootstrap, and
// send the OnShimConnected message.
void SendBootstrapOnShimConnected(mojo::PlatformChannelEndpoint endpoint);
// Init step 4 (the last): The browser response to OnShimConnected. On
// success, this will initialize |shim_receiver_|, through which |this| will
// be controlled by the browser. On failure, the app will quit.
void OnShimConnectedResponse(
chrome::mojom::AppShimLaunchResult result,
variations::VariationsCommandLine feature_state,
mojo::PendingReceiver<chrome::mojom::AppShim> app_shim_receiver);
// Builds main menu bar items.
void SetUpMenu();
void ChannelError(uint32_t custom_reason, const std::string& description);
void BootstrapChannelError(uint32_t custom_reason,
const std::string& description);
// chrome::mojom::AppShim implementation.
void CreateRemoteCocoaApplication(
mojo::PendingAssociatedReceiver<remote_cocoa::mojom::Application>
receiver) override;
void CreateCommandDispatcherForWidget(uint64_t widget_id) override;
void SetBadgeLabel(const std::string& badge_label) override;
void SetUserAttention(
chrome::mojom::AppShimAttentionType attention_type) override;
void UpdateProfileMenu(std::vector<chrome::mojom::ProfileMenuItemPtr>
profile_menu_items) override;
void UpdateApplicationDockMenu(
std::vector<chrome::mojom::ApplicationDockMenuItemPtr> dock_menu_items)
override;
void BindNotificationProvider(
mojo::PendingReceiver<mac_notifications::mojom::MacNotificationProvider>
provider) override;
void RequestNotificationPermission(
RequestNotificationPermissionCallback callback) override;
void BindChildHistogramFetcherFactory(
mojo::PendingReceiver<metrics::mojom::ChildHistogramFetcherFactory>
receiver) override;
// mac_notifications::mojom::MacNotificationProvider implementation.
void BindNotificationService(
mojo::PendingReceiver<mac_notifications::mojom::MacNotificationService>
service,
mojo::PendingRemote<
mac_notifications::mojom::MacNotificationActionHandler> handler)
override;
// Called when a change in the system notification permission status has been
// detected.
void NotificationPermissionStatusChanged(
mac_notifications::mojom::PermissionStatus status);
bool WebAppIsAdHocSigned() const;
// Helper function to set up a connection to the AppShimListener at the given
// Mach endpoint name.
static mojo::PlatformChannelEndpoint ConnectToBrowser(
const mojo::NamedPlatformChannel::ServerName& server_name);
// Helper function to search for the Chrome instance holding
// chrome::kSingletonLockFilename in the specified |user_data_dir|.
static NSRunningApplication* FindChromeFromSingletonLock(
const base::FilePath& user_data_dir);
static void CreateRenderWidgetHostNSView(
uint64_t view_id,
mojo::ScopedInterfaceEndpointHandle host_handle,
mojo::ScopedInterfaceEndpointHandle view_request_handle);
static NSObject<RenderWidgetHostViewMacDelegate>* GetDelegateForHost(
uint64_t view_id);
const Params params_;
// Populated by OpenFiles if it was called before OnAppFinishedLaunching
// was called.
std::vector<base::FilePath> launch_files_;
// Populated by OpenUrls if it was called before OnAppFinishedLaunching
// was called.
std::vector<GURL> launch_urls_;
// Populated by OnAppfinishedLaunching to indicate if this app was launched
// as a result of a notification action.
bool launched_by_notification_action_ = false;
// This is the Chrome process that this app is committed to connecting to.
// The app will quit if this process is terminated before the mojo connection
// is established.
// This process is determined by either:
// - The pid specified to the app's command line (if it exists).
// - The pid specified in the chrome::kSingletonLockFilename file.
NSRunningApplication* __strong chrome_to_connect_to_;
// The Chrome process that was launched by this app in FindOrLaunchChrome.
// Note that the app is not compelled to connect to this process (consider the
// case where multiple apps launch at the same time, and all launch their own
// Chrome -- only one will grab the chrome::kSingletonLockFilename, and all
// apps should connect to that).
NSRunningApplication* __strong chrome_launched_by_app_;
mojo::IsolatedConnection bootstrap_mojo_connection_;
mojo::Remote<chrome::mojom::AppShimHostBootstrap> host_bootstrap_;
mojo::Receiver<chrome::mojom::AppShim> shim_receiver_{this};
mojo::Remote<chrome::mojom::AppShimHost> host_;
mojo::PendingReceiver<chrome::mojom::AppShimHost> host_receiver_;
mojo::Receiver<mac_notifications::mojom::MacNotificationProvider>
notifications_receiver_{this};
AppShimDelegate* __strong delegate_;
InitState init_state_ = InitState::kWaitingForAppToFinishLaunch;
// The target for NSMenuItems in the profile menu.
ProfileMenuTarget* __strong profile_menu_target_;
// The target for NSMenuItems in the application dock menu.
ApplicationDockMenuTarget* __strong application_dock_menu_target_;
// The screen object used in the app sim.
std::unique_ptr<display::ScopedNativeScreen> screen_;
// The items in the profile menu.
std::vector<chrome::mojom::ProfileMenuItemPtr> profile_menu_items_;
// The items in the application dock menu.
std::vector<chrome::mojom::ApplicationDockMenuItemPtr> dock_menu_items_;
// MacNotificationService implementation used by Chrome to display
// notifications in this app shim process.
std::unique_ptr<mac_notifications::mojom::MacNotificationService>
notification_service_;
// Remote and receiver used for passing notification actions to the browser
// process. The receiver end is passed to the browser process when connection
// is established, while the remote end is passed to
// `MacNotificationServiceUN` when it is constructed.
mojo::PendingRemote<mac_notifications::mojom::MacNotificationActionHandler>
notification_action_handler_remote_;
mojo::PendingReceiver<mac_notifications::mojom::MacNotificationActionHandler>
notification_action_handler_receiver_ =
notification_action_handler_remote_.InitWithNewPipeAndPassReceiver();
NSInteger attention_request_id_ = 0;
};
#endif // CHROME_APP_SHIM_APP_SHIM_CONTROLLER_H_
Codebase Browser
chromium