blob: 3b8d90aacaacac61c71b31ba25507b99b3800f58 [file] [log] [blame]
// 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 <map>
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "base/memory/weak_ptr.h"
#include "mojo/application/public/interfaces/application.mojom.h"
#include "mojo/application/public/interfaces/service_provider.mojom.h"
#include "mojo/application/public/interfaces/shell.mojom.h"
#include "mojo/shell/application_loader.h"
#include "mojo/shell/capability_filter.h"
#include "mojo/shell/connect_to_application_params.h"
#include "mojo/shell/fetcher.h"
#include "mojo/shell/identity.h"
#include "mojo/shell/native_runner.h"
#include "third_party/mojo/src/mojo/public/cpp/bindings/interface_ptr_info.h"
#include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
#include "url/gurl.h"
namespace base {
class FilePath;
class SequencedWorkerPool;
namespace mojo {
namespace shell {
class PackageManager;
class ApplicationInstance;
class ContentHandlerConnection;
class ApplicationManager {
// API for testing.
class TestAPI {
explicit TestAPI(ApplicationManager* manager);
// Returns true if the shared instance has been created.
static bool HasCreatedInstance();
// Returns true if there is a ApplicationInstance for this URL.
bool HasRunningInstanceForURL(const GURL& url) const;
ApplicationManager* manager_;
// Creates an ApplicationManager.
// |package_manager| is an instance of an object that handles URL resolution,
// fetching and updating of applications. See package_manager.h.
explicit ApplicationManager(scoped_ptr<PackageManager> package_manager);
// |native_runner_factory| is an instance of an object capable of vending
// implementations of NativeRunner, e.g. for in or out-of-process execution.
// See native_runner.h and RunNativeApplication().
// |task_runner| provides access to a thread to perform file copy operations
// on. This may be null only in testing environments where applications are
// loaded via ApplicationLoader implementations.
ApplicationManager(scoped_ptr<PackageManager> package_manager,
scoped_ptr<NativeRunnerFactory> native_runner_factory,
base::TaskRunner* task_runner);
// Loads a service if necessary and establishes a new client connection.
// Please see the comments in connect_to_application_params.h for more details
// about the parameters.
void ConnectToApplication(scoped_ptr<ConnectToApplicationParams> params);
// Sets the default Loader to be used if not overridden by SetLoaderForURL().
void set_default_loader(scoped_ptr<ApplicationLoader> loader) {
default_loader_ = loader.Pass();
// Sets a Loader to be used for a specific url.
void SetLoaderForURL(scoped_ptr<ApplicationLoader> loader, const GURL& url);
// Destroys all Shell-ends of connections established with Applications.
// Applications connected by this ApplicationManager will observe pipe errors
// and have a chance to shutdown.
void TerminateShellConnections();
// Removes a ApplicationInstance when it encounters an error.
void OnApplicationInstanceError(ApplicationInstance* instance);
ApplicationInstance* GetApplicationInstance(const Identity& identity) const;
using IdentityToInstanceMap = std::map<Identity, ApplicationInstance*>;
using URLToLoaderMap = std::map<GURL, ApplicationLoader*>;
// Takes the contents of |params| only when it returns true.
bool ConnectToRunningApplication(
scoped_ptr<ConnectToApplicationParams>* params);
InterfaceRequest<Application> CreateInstance(
scoped_ptr<ConnectToApplicationParams> params,
ApplicationInstance** instance);
// Called once |fetcher| has found app. |params->app_url()| is the url of
// the requested application before any mappings/resolution have been applied.
// The corresponding URLRequest struct in |params| has been taken.
void HandleFetchCallback(scoped_ptr<ConnectToApplicationParams> params,
scoped_ptr<Fetcher> fetcher);
void RunNativeApplication(InterfaceRequest<Application> application_request,
bool start_sandboxed,
scoped_ptr<Fetcher> fetcher,
const base::FilePath& file_path,
bool path_exists);
// Returns the appropriate loader for |url|, or the default loader if there is
// no loader configured for the URL.
ApplicationLoader* GetLoaderForURL(const GURL& url);
void CleanupRunner(NativeRunner* runner);
scoped_ptr<PackageManager> const package_manager_;
// Loader management.
// Loaders are chosen in the order they are listed here.
URLToLoaderMap url_to_loader_;
scoped_ptr<ApplicationLoader> default_loader_;
IdentityToInstanceMap identity_to_instance_;
base::TaskRunner* task_runner_;
scoped_ptr<NativeRunnerFactory> native_runner_factory_;
ScopedVector<NativeRunner> native_runners_;
base::WeakPtrFactory<ApplicationManager> weak_ptr_factory_;
Shell::ConnectToApplicationCallback EmptyConnectCallback();
} // namespace shell
} // namespace mojo