Adding overview / layer framework to Activities so that unloaded / sleeping activities can be shown…

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/content_proxy.h"
 #include "athena/content/public/app_registry.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/public/window_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/aura/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(const std::string& app_id)
     : app_id_(app_id),
       web_view_(NULL),
       current_state_(ACTIVITY_UNLOADED),
       app_activity_registry_(NULL) {
 }
 
+scoped_ptr<ContentProxy> AppActivity::GetContentProxy(aura::Window* window) {
+  if (content_proxy_.get())
+    content_proxy_->Reparent(window);
+  return content_proxy_.Pass();
+}
+
 ActivityViewModel* AppActivity::GetActivityViewModel() {
   return this;
 }
 
 void AppActivity::SetCurrentState(Activity::ActivityState state) {
   DCHECK_NE(state, current_state_);
   ActivityState current_state = current_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:
-      MakeVisible();
+      HideContentProxy();
       return;
     case ACTIVITY_INVISIBLE:
       if (current_state == ACTIVITY_VISIBLE)
-        MakeInvisible();
+        ShowContentProxy();
       break;
     case ACTIVITY_BACKGROUND_LOW_PRIORITY:
       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);
       // TODO(skuhne): Do this.
       break;
@@ skipping 61 matching lines @@
 
 bool AppActivity::UsesFrame() const {
   return false;
 }
 
 views::View* AppActivity::GetContentsView() {
   if (!web_view_) {
     web_view_ = GetWebView();
     // Make sure the content gets properly shown.
     if (current_state_ == ACTIVITY_VISIBLE) {
-      MakeVisible();
+      HideContentProxy();
     } else if (current_state_ == ACTIVITY_INVISIBLE) {
-      MakeInvisible();
+      ShowContentProxy();
     } else {
       // If not previously specified, we change the state now to invisible..
       SetCurrentState(ACTIVITY_INVISIBLE);
     }
     RegisterActivity();
   }
   return web_view_;
 }
 
-void AppActivity::CreateOverviewModeImage() {
-  // TODO(skuhne): Implement this!
-}
-
 gfx::ImageSkia AppActivity::GetOverviewModeImage() {
-  return overview_mode_image_;
+  if (content_proxy_.get())
+    return content_proxy_->GetContentImage();
+  return gfx::ImageSkia();
 }
 
 void AppActivity::PrepareContentsForOverview() {
   // Turn on fast resizing to avoid re-laying out the web contents when
-  // entering / exiting overview mode.
-  web_view_->SetFastResize(true);
+  // entering / exiting overview mode and the content is visible.
+  if (!content_proxy_.get())
+    web_view_->SetFastResize(true);
 }
 
 void AppActivity::ResetContentsView() {
-  web_view_->SetFastResize(false);
-  web_view_->Layout();
+  // Turn on fast resizing to avoid re-laying out the web contents when
+  // entering / exiting overview mode and the content is visible.
+  if (!content_proxy_.get()) {
+    web_view_->SetFastResize(false);
+    web_view_->Layout();
+  }
 }
 
 AppActivity::~AppActivity() {
   // If this activity is registered, we unregister it now.
   if (app_activity_registry_)
     app_activity_registry_->UnregisterAppActivity(this);
 }
 
 void AppActivity::TitleWasSet(content::NavigationEntry* entry,
                               bool explicit_set) {
@@ skipping 12 matching lines @@
   content::WebContents* web_contents = web_view_->GetWebContents();
   AppRegistry* app_registry = AppRegistry::Get();
   // Get the application's registry.
   app_activity_registry_ = app_registry->GetAppActivityRegistry(
       app_id_, web_contents->GetBrowserContext());
   DCHECK(app_activity_registry_);
   // Register the activity.
   app_activity_registry_->RegisterAppActivity(this);
 }
 
-void AppActivity::MakeVisible() {
-  // TODO(skuhne): Once we know how to handle the Overview mode, this has to
-  // be moved into an ActivityContentController which is used by all activities.
-  // Make the content visible.
-  // TODO(skuhne): If this can be combined with web_activity, move this into a
-  // separate class.
-  web_view_->SetVisible(true);
-  web_view_->GetWebContents()->GetNativeView()->Show();
-
-  // Remove our proxy image.
-  // TODO(skuhne): Once we have figured out how to do overview mode that code
-  // needs to go here.
-  overview_mode_image_ = gfx::ImageSkia();
+void AppActivity::HideContentProxy() {
+  content_proxy_.reset();
 }
 
-void AppActivity::MakeInvisible() {
-  // TODO(skuhne): Once we know how to handle the Overview mode, this has to
-  // be moved into an ActivityContentController which is used by all activities.
-  // TODO(skuhne): If this can be combined with web_activity, move this into a
-  // separate class.
-  DCHECK(web_view_->visible());
-  // Create our proxy image.
-  if (current_state_ == ACTIVITY_VISIBLE) {
-    // Create a proxy image of the current visible content.
-    // TODO(skuhne): Do this once we figure out how to do overview mode.
-    overview_mode_image_ = gfx::ImageSkia();
-  }
-  // Now we can hide this.
-  // Note: This might have to be done asynchronously after the readback took
-  // place.
-  web_view_->SetVisible(false);
-  web_view_->GetWebContents()->GetNativeView()->Hide();
+void AppActivity::ShowContentProxy() {
+  if (!content_proxy_.get() && web_view_)
+    content_proxy_.reset(new ContentProxy(web_view_, this));
 }
 
 }  // namespace athena