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

athena/content/web_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/web_activity.h"
 
 #include "athena/activity/public/activity_factory.h"
 #include "athena/activity/public/activity_manager.h"
+#include "athena/content/content_proxy.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_switches.h"
 #include "ui/aura/window.h"
@@ skipping 149 matching lines @@
   }
 
   virtual ~AthenaWebView() {}
 
   void InstallAccelerators() { controller_->InstallAccelerators(); }
 
   void EvictContent() {
     scoped_ptr<content::WebContents> old_contents(SwapWebContents(
         scoped_ptr<content::WebContents>(content::WebContents::Create(
             content::WebContents::CreateParams(browser_context())))));
+    // If there is a progress bar, we need to get rid of it now since its
+    // associated content, parent window and layers will disappear with evicting
+    // the content.
+    progress_bar_.reset();
     evicted_web_contents_.reset(
         content::WebContents::Create(content::WebContents::CreateParams(
             old_contents->GetBrowserContext())));
     evicted_web_contents_->GetController().CopyStateFrom(
         old_contents->GetController());
     // As soon as the new contents becomes visible, it should reload.
     // TODO(skuhne): This breaks script connections with other activities.
     // Even though this is the same technique as used by the TabStripModel,
     // we might want to address this cleaner since we are more likely to
     // run into this state. by unloading.
@@ skipping 165 matching lines @@
 ActivityViewModel* WebActivity::GetActivityViewModel() {
   return this;
 }
 
 void WebActivity::SetCurrentState(Activity::ActivityState state) {
   DCHECK_NE(state, current_state_);
   switch (state) {
     case ACTIVITY_VISIBLE:
       if (!web_view_)
         break;
-      MakeVisible();
+      HideContentProxy();
       ReloadAndObserve();
       break;
     case ACTIVITY_INVISIBLE:
       if (!web_view_)
         break;
+
       if (current_state_ == ACTIVITY_VISIBLE)
-        MakeInvisible();
-      ReloadAndObserve();
+        ShowContentProxy();
+      else
+        ReloadAndObserve();
+
       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. As soon as the new resource management is
       // agreed upon - or remove otherwise.
       break;
     case ACTIVITY_UNLOADED:
       DCHECK_NE(ACTIVITY_UNLOADED, current_state_);
+      if (content_proxy_.get())
+        content_proxy_->ContentWillUnload();
       Observe(NULL);
       web_view_->EvictContent();
       break;
   }
   // Remember the last requested state.
   current_state_ = state;
 }
 
 Activity::ActivityState WebActivity::GetCurrentState() {
   // If the content is evicted, the state has to be UNLOADED.
@@ skipping 42 matching lines @@
 bool WebActivity::UsesFrame() const {
   return true;
 }
 
 views::View* WebActivity::GetContentsView() {
   if (!web_view_) {
     web_view_ = new AthenaWebView(browser_context_);
     web_view_->LoadInitialURL(url_);
     // Make sure the content gets properly shown.
     if (current_state_ == ACTIVITY_VISIBLE) {
-      MakeVisible();
+      HideContentProxy();
       ReloadAndObserve();
     } else if (current_state_ == ACTIVITY_INVISIBLE) {
-      MakeInvisible();
+      ShowContentProxy();
       ReloadAndObserve();
     } else {
       // If not previously specified, we change the state now to invisible..
       SetCurrentState(ACTIVITY_INVISIBLE);
     }
   }
   return web_view_;
 }
 
-void WebActivity::CreateOverviewModeImage() {
-  // TODO(skuhne): Create an overview.
-}
-
 gfx::ImageSkia WebActivity::GetOverviewModeImage() {
-  return overview_mode_image_;
+  if (content_proxy_.get())
+    content_proxy_->GetContentImage();
+  return gfx::ImageSkia();
 }
 
 void WebActivity::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 WebActivity::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();
+  }
 }
 
 void WebActivity::TitleWasSet(content::NavigationEntry* entry,
                               bool explicit_set) {
   ActivityManager::Get()->UpdateActivity(this);
 }
 
 void WebActivity::DidUpdateFaviconURL(
     const std::vector<content::FaviconURL>& candidates) {
   ActivityManager::Get()->UpdateActivity(this);
 }
 
 void WebActivity::DidChangeThemeColor(SkColor theme_color) {
   title_color_ = theme_color;
   ActivityManager::Get()->UpdateActivity(this);
 }
 
-void WebActivity::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 app_activity, move this into a
-  // separate class.
-  web_view_->SetVisible(true);
-  web_view_->GetWebContents()->GetNativeView()->Show();
-  // If we have a proxy image, we can delete it now since the contet goes live.
-  // TODO(skuhne): Once we have figured out how to do overview mode that code
-  // needs to go here.
-  overview_mode_image_ = gfx::ImageSkia();
+void WebActivity::HideContentProxy() {
+  if (content_proxy_.get())
+    content_proxy_.reset(NULL);
 }
 
-void WebActivity::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 app_activity, move this into a
-  // separate class.
-  DCHECK(web_view_->visible());
-  // Create our proxy image / layer.
-  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 read back took
-  // place.
-  web_view_->GetWebContents()->GetNativeView()->Hide();
-  web_view_->SetVisible(false);
+void WebActivity::ShowContentProxy() {
+  if (!content_proxy_.get() && web_view_)
+    content_proxy_.reset(new ContentProxy(web_view_, this));
 }
 
 void WebActivity::ReloadAndObserve() {
   if (web_view_->IsContentEvicted()) {
     DCHECK_EQ(ACTIVITY_UNLOADED, current_state_);
     web_view_->ReloadContent();
   }
   Observe(web_view_->GetWebContents());
 }
 
 }  // namespace athena