| // 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 ATHENA_CONTENT_APP_ACTIVITY_REGISTRY_H_ |
| #define ATHENA_CONTENT_APP_ACTIVITY_REGISTRY_H_ |
| |
| #include <vector> |
| |
| #include "athena/activity/public/activity_view_model.h" |
| #include "athena/content/app_activity_proxy.h" |
| #include "ui/gfx/image/image_skia.h" |
| |
| namespace aura { |
| class Window; |
| } |
| |
| namespace content { |
| class BrowserContext; |
| } |
| |
| namespace athena { |
| |
| class AppActivity; |
| |
| // This class keeps track of all existing |AppActivity|s and shuts down all of |
| // them when the application gets unloaded to save memory. It will then replace |
| // the |AppActivity| in the Activity list as proxy to allow restarting of the |
| // application. |
| class ATHENA_EXPORT AppActivityRegistry { |
| public: |
| AppActivityRegistry(const std::string& app_id, |
| content::BrowserContext* browser_context); |
| ~AppActivityRegistry(); |
| |
| // Register an |AppActivity| with this application. |
| void RegisterAppActivity(AppActivity* app_activity); |
| |
| // Unregister a previously attached |AppActivity|. |
| // Note that detaching the last |AppActivity| will delete this object - unless |
| // the resource manager was trying to unload the application. |
| // Note furthermore that Detach can be called without ever being registered. |
| void UnregisterAppActivity(AppActivity* app_activity); |
| |
| // Returns the number of activities/windows with this application. |
| int NumberOfActivities() const { return activity_list_.size(); } |
| |
| // Returns the |AppActivity| at |index|. It will return nullptr if an invalid |
| // index was specified. |
| AppActivity* GetAppActivityAt(size_t index); |
| |
| // Unload all application associated activities to save resources. |
| void Unload(); |
| |
| // Returns true if the application is in the unloaded state. |
| bool IsUnloaded() { return unloaded_activity_proxy_ != nullptr; } |
| |
| content::BrowserContext* browser_context() const { return browser_context_; } |
| const std::string& app_id() const { return app_id_; } |
| |
| // Returns the proxy - if there is one. This will get used by a newly created |
| // activity to position itself in its place before it get destroyed. |
| Activity* unloaded_activity_proxy() { return unloaded_activity_proxy_; } |
| |
| protected: |
| friend AppActivityProxy; |
| |
| // When the |AppActivityProxy| gets destroyed it should call this function |
| // to disconnect from this object. This call might destroy |this|. |
| void ProxyDestroyed(AppActivityProxy* proxy); |
| |
| // When called by the |AppActivityProxy| to restart the application, it can |
| // cause the application to restart. When that happens the proxy will get |
| // destroyed. After this call |this| might be destroyed. |
| void RestartApplication(AppActivityProxy* proxy); |
| |
| private: |
| // Called if an unload of an application should take place asynchronously to |
| // avoid object destruction within an observer handler. |
| void DelayedUnload(); |
| |
| // Gets most recently used AppAcitivty that belongs to the same application. |
| AppActivity* GetMruActivity(); |
| |
| // A list of all activities associated with this application. |
| std::vector<AppActivity*> activity_list_; |
| |
| // The application id for this proxy. |
| std::string app_id_; |
| |
| // The browser context of the user. |
| content::BrowserContext* browser_context_; |
| |
| // When the activity is unloaded this is the AppActivityProxy. The object is |
| // owned the the ActivityManager. |
| AppActivityProxy* unloaded_activity_proxy_; |
| |
| // The presentation values. |
| SkColor color_; |
| base::string16 title_; |
| gfx::ImageSkia image_; |
| |
| DISALLOW_COPY_AND_ASSIGN(AppActivityRegistry); |
| }; |
| |
| } // namespace athena |
| |
| #endif // ATHENA_CONTENT_APP_ACTIVITY_REGISTRY_H_ |