Athena: Adding basic resource management framework (un-/re-loading) of V2 applications

athena/content/app_activity.cc

 // 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 "athena/content/app_activity.h"
 
 #include "athena/activity/public/activity_manager.h"
+#include "athena/content/app_activity_registry.h"
+#include "athena/content/public/app_content_delegate.h"
+#include "athena/content/public/app_registry.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/shell/browser/shell_app_window.h"
 #include "ui/views/controls/webview/webview.h"
+#include "ui/views/widget/widget.h"
 
 namespace athena {
 
 // TODO(mukai): specifies the same accelerators of WebActivity.
 AppActivity::AppActivity(extensions::ShellAppWindow* app_window)
     : app_window_(app_window),
       web_view_(NULL),
-      current_state_(ACTIVITY_UNLOADED) {
-  DCHECK(app_window_);
+      current_state_(ACTIVITY_UNLOADED),
+      app_activity_registry_(NULL) {
 }
 
 AppActivity::~AppActivity() {
-  if (GetCurrentState() != ACTIVITY_UNLOADED)
-    SetCurrentState(ACTIVITY_UNLOADED);
+  // If this activity is registered, we unregister it now.
+  if (app_activity_registry_)
+    app_activity_registry_->UnregisterAppActivity(this);
 }
 
 ActivityViewModel* AppActivity::GetActivityViewModel() {
   return this;
 }
 
 void AppActivity::SetCurrentState(Activity::ActivityState state) {
+  ActivityState current_state = state;
+  // Remember the last requested state now so that a call to GetCurrentState()
+  // returns the new state.
+  current_state_ = state;
+
   switch (state) {
     case ACTIVITY_VISIBLE:
       // Fall through (for the moment).
     case ACTIVITY_INVISIBLE:
       // By clearing the overview mode image we allow the content to be shown.
       overview_mode_image_ = gfx::ImageSkia();
-      // TODO(skuhne): Find out how to reload an app from the extension system.
+      // Note: A reload from the unloaded state will be performed through the
+      // |AppActivityProxy| object and no further action isn't necessary here.
       break;
     case ACTIVITY_BACKGROUND_LOW_PRIORITY:
-      DCHECK(ACTIVITY_VISIBLE == current_state_ ||
-             ACTIVITY_INVISIBLE == current_state_);
+      DCHECK(ACTIVITY_VISIBLE == current_state ||
+             ACTIVITY_INVISIBLE == current_state);
       // TODO(skuhne): Do this.
       break;
     case ACTIVITY_PERSISTENT:
-      DCHECK_EQ(ACTIVITY_BACKGROUND_LOW_PRIORITY, current_state_);
+      DCHECK_EQ(ACTIVITY_BACKGROUND_LOW_PRIORITY, current_state);
       // TODO(skuhne): Do this.
       break;
     case ACTIVITY_UNLOADED:
-      DCHECK_NE(ACTIVITY_UNLOADED, current_state_);
-      // TODO(skuhne): Find out how to evict an app from the extension system.
-      //      web_view_->EvictContent();
+      DCHECK_NE(ACTIVITY_UNLOADED, current_state);
+      // This will cause the application to shut down, close its windows and
+      // delete this object. Instead a |AppActivityProxy| will be created as
+      // place holder.
+      if (app_activity_registry_)
+        app_activity_registry_->Unload();

[oshima, 2014/08/15 15:15:59]

Design question rather than code question:

I guess when unloading, all activities that belongs to an app gets UNLOAD
request. Correct?

Isn't it more natural for resource manager to tell app_registry to
unload, and then registry unloads/removes Activity's view?

[Mr4D (OOO till 08-26), 2014/08/18 16:09:32]

Actually... I implemented it the way that each activity can get an UNLOAD
request separately by the resource manager. However - unloading a single
activity isn't possible without unloading the entire app. As such the unload
will only be performed when all activities were unloaded by the resource manager
(e.g. each activity is too old).

When that happens it will close(!!) all activities and create the one
proxy/dummy activity.

This is unfortunately required since there is no guarantee that the app will
re-create all of its app windows upon restart.

So - the resource manager will only communicate with activities.

       break;
   }
-  // Remember the last requested state.
-  current_state_ = state;
 }
 
 Activity::ActivityState AppActivity::GetCurrentState() {
-  // TODO(skuhne): Check here also eviction status.
   if (!web_view_) {
     DCHECK_EQ(ACTIVITY_UNLOADED, current_state_);
     return ACTIVITY_UNLOADED;
   }
   // TODO(skuhne): This should be controlled by an observer and should not
   // reside here.
   if (IsVisible() && current_state_ != ACTIVITY_VISIBLE)
     SetCurrentState(ACTIVITY_VISIBLE);
   // Note: If the activity is not visible it does not necessarily mean that it
   // does not have GPU compositor resources (yet).
   return current_state_;
 }
 
 bool AppActivity::IsVisible() {
   return web_view_ && web_view_->IsDrawn();
 }
 
 Activity::ActivityMediaState AppActivity::GetMediaState() {
   // TODO(skuhne): The function GetTabMediaStateForContents(WebContents),
   // and the AudioStreamMonitor needs to be moved from Chrome into contents to
   // make it more modular and so that we can use it from here.
   return Activity::ACTIVITY_MEDIA_STATE_NONE;
 }
 
+aura::Window* AppActivity::GetWindow() {
+  if (!web_view_)

[oshima, 2014/08/15 15:15:59]

nit:
 ? :

[Mr4D (OOO till 08-26), 2014/08/18 16:09:32]

Done.

+    return NULL;
+  return web_view_->GetWidget()->GetNativeWindow();
+}
+
 void AppActivity::Init() {
 }
 
 SkColor AppActivity::GetRepresentativeColor() const {
   // TODO(sad): Compute the color from the favicon.
   return SK_ColorGRAY;
 }
 
 base::string16 AppActivity::GetTitle() const {
   return web_view_->GetWebContents()->GetTitle();
@@ skipping 28 matching lines @@
 void AppActivity::TitleWasSet(content::NavigationEntry* entry,
                               bool explicit_set) {
   ActivityManager::Get()->UpdateActivity(this);
 }
 
 void AppActivity::DidUpdateFaviconURL(
     const std::vector<content::FaviconURL>& candidates) {
   ActivityManager::Get()->UpdateActivity(this);
 }
 
+void AppActivity::DidStartNavigationToPendingEntry(
+      const GURL& url,
+      content::NavigationController::ReloadType reload_type) {
+  if (!app_activity_registry_)

[oshima, 2014/08/15 15:15:59]

can this be NULL in this callback?

[Mr4D (OOO till 08-26), 2014/08/18 16:09:32]

Yes upon first call the app_id is unknown since GetContentsView got called as
part of the creation process. Then the url get set (which allows to figure out
the app id). I had a different patch in which the AppShellWindow got a call to
return the app_id instead (which was much better then this), but since we change
away from using AppShellWindow I reverted this additional interface change and
we re-visit this part when we have the new AppWindow.

+    RegisterActivity();
+}
+
+// Register an |activity| with an application.
+// Note: This should only get called once for an |app_window| of the
+// |activity|.
+void AppActivity::RegisterActivity() {
+  if (app_activity_registry_)
+    return;
+  content::WebContents* web_contents = app_window_->GetAssociatedWebContents();
+  AppRegistry* app_registry = AppRegistry::Get();
+  // Get the application's registry.
+  app_activity_registry_ = app_registry->GetAppActivityRegistry(
+          app_registry->GetDelegate()->GetExtensionID(web_contents),
+          web_contents->GetBrowserContext());
+  DCHECK(app_activity_registry_);
+  // Register the activity.
+  app_activity_registry_->RegisterAppActivity(this);
+}
+
 }  // namespace athena