#include <map>
#include <set>
#include <string>
+#include <vector>
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_vector.h"
#include "base/observer_list.h"
+#include "content/public/browser/render_process_host_observer.h"
#include "ui/base/ui_base_types.h"
-#include "xwalk/application/browser/event_observer.h"
#include "xwalk/application/common/application_data.h"
+#include "xwalk/application/common/security_policy.h"
#include "xwalk/runtime/browser/runtime.h"
+
+namespace content {
+ class RenderProcessHost;
+}
+
namespace xwalk {
class RuntimeContext;
class ApplicationHost;
class Manifest;
+class SecurityPolicy;
// The Application class is representing an active (running) application.
// Application instances are owned by ApplicationService.
// terminated.
// There's one-to-one correspondence between Application and Render Process
// Host, obtained from its "runtimes" (pages).
-class Application : public Runtime::Observer {
+class Application : public Runtime::Observer,
+ public content::RenderProcessHostObserver {
public:
virtual ~Application();
// Manifest keys that can be used as application entry points.
enum LaunchEntryPoint {
- AppMainKey = 1 << 0, // app.main
+ StartURLKey = 1 << 0, // start_url
LaunchLocalPathKey = 1 << 1, // app.launch.local_path
- // NOTE: The following key is only used for "dummy" hosted apps,
- // which can be using any arbitrary URL, incl. remote ones.
- // For now this should be disabled for all other cases as this will
- // require special care with permissions etc.
URLKey = 1 << 2, // url
- Default = AppMainKey | LaunchLocalPathKey
+ Default = StartURLKey | LaunchLocalPathKey
};
typedef unsigned LaunchEntryPoints;
LaunchParams() :
entry_points(Default),
launcher_pid(0),
- window_state(ui::SHOW_STATE_DEFAULT) {}
+ force_fullscreen(false) {}
LaunchEntryPoints entry_points;
// process.
int32 launcher_pid;
- // Sets the initial state for the application windows.
- ui::WindowShowState window_state;
+ bool force_fullscreen;
};
// Closes all the application's runtimes (application pages).
//
// NOTE: ApplicationService deletes an Application instance
// immediately after its termination.
- enum TerminationMode {
- Normal,
- Immediate // Ignore OnSuspend event handler.
- };
- void Terminate(TerminationMode = Normal);
-
- // Returns Runtime (application page) containing the application's
- // 'main document'. The main document is the main entry point of
- // the application to the system. This method will return 'NULL'
- // if application has different entry point (local path manifest key).
- // See http://anssiko.github.io/runtime/app-lifecycle.html#dfn-main-document
- // The main document never has a visible window on its own.
- Runtime* GetMainDocumentRuntime() const;
+ void Terminate();
const std::set<Runtime*>& runtimes() const { return runtimes_; }
// Returns the unique application id which is used to distinguish the
// application amoung both running applications and installed ones
// (ApplicationData objects).
- std::string id() const { return application_data_->ID(); }
+ std::string id() const { return data_->ID(); }
int GetRenderProcessHostID() const;
- const ApplicationData* data() const { return application_data_; }
- ApplicationData* data() { return application_data_; }
+ const ApplicationData* data() const { return data_; }
+ ApplicationData* data() { return data_; }
// Tells whether the application use the specified extension.
bool UseExtension(const std::string& extension_name) const;
const std::string& api_name) const;
StoredPermission GetPermission(PermissionType type,
- std::string& permission_name) const;
+ const std::string& permission_name) const;
bool SetPermission(PermissionType type,
const std::string& permission_name,
StoredPermission perm);
+ bool CanRequestURL(const GURL& url) const;
- private:
- bool HasMainDocument() const;
- // Runtime::Observer implementation.
- virtual void OnRuntimeAdded(Runtime* runtime) OVERRIDE;
- virtual void OnRuntimeRemoved(Runtime* runtime) OVERRIDE;
-
+ protected:
// We enforce ApplicationService ownership.
friend class ApplicationService;
Application(scoped_refptr<ApplicationData> data,
RuntimeContext* context,
Observer* observer);
- bool Launch(const LaunchParams& launch_params);
+ virtual bool Launch(const LaunchParams& launch_params);
+ virtual void InitSecurityPolicy();
+ void AddSecurityPolicy(const GURL& url, bool subdomains);
+
+ std::set<Runtime*> runtimes_;
+ scoped_refptr<ApplicationData> const data_;
+ // The application's render process host.
+ content::RenderProcessHost* render_process_host_;
+ bool security_mode_enabled_;
+
+ private:
+ // Runtime::Observer implementation.
+ virtual void OnRuntimeAdded(Runtime* runtime) OVERRIDE;
+ virtual void OnRuntimeRemoved(Runtime* runtime) OVERRIDE;
+
+ // content::RenderProcessHostObserver implementation.
+ virtual void RenderProcessExited(content::RenderProcessHost* host,
+ base::ProcessHandle handle,
+ base::TerminationStatus status,
+ int exit_code) OVERRIDE;
+ virtual void RenderProcessHostDestroyed(
+ content::RenderProcessHost* host) OVERRIDE;
// Try to extract the URL from different possible keys for entry points in the
// manifest, returns it and the entry point used.
- GURL GetURLForLaunch(const LaunchParams& params, LaunchEntryPoint* used);
+ GURL GetStartURL(const LaunchParams& params, LaunchEntryPoint* used);
+ ui::WindowShowState GetWindowShowStateWGT(const LaunchParams& params);
+ ui::WindowShowState GetWindowShowStateXPK(const LaunchParams& params);
- GURL GetURLFromAppMainKey();
- GURL GetURLFromLocalPathKey();
GURL GetURLFromURLKey();
- friend class FinishEventObserver;
- void CloseMainDocument();
+ GURL GetURLFromRelativePathKey(const std::string& key);
+
void NotifyTermination();
- bool IsOnSuspendHandlerRegistered() const;
- bool IsTerminating() const { return finish_observer_; }
RuntimeContext* runtime_context_;
- const scoped_refptr<ApplicationData> application_data_;
- Runtime* main_runtime_;
- std::set<Runtime*> runtimes_;
- scoped_ptr<EventObserver> finish_observer_;
Observer* observer_;
// The entry point used as part of Launch().
LaunchEntryPoint entry_point_used_;
- TerminationMode termination_mode_used_;
- base::WeakPtrFactory<Application> weak_factory_;
std::map<std::string, std::string> name_perm_map_;
// Application's session permissions.
StoredPermissionMap permission_map_;
-
+ // Security policy set.
+ ScopedVector<SecurityPolicy> security_policy_;
+ // WeakPtrFactory should be always declared the last.
+ base::WeakPtrFactory<Application> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(Application);
};
projects / platform / framework / web / crosswalk.git / blobdiff