Decoupling visibility states from webcontent, adding visibility management in ResourceManager

content/browser/web_contents/web_contents_view_aura.cc

 // Copyright (c) 2012 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 "content/browser/web_contents/web_contents_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
@@ skipping 1579 matching lines @@
   if (parent)
     UpdateWebContentsVisibility(window->IsVisible());
 }
 
 void WebContentsViewAura::OnWindowVisibilityChanged(aura::Window* window,
                                                     bool visible) {
   // Ignore any visibility changes in the hierarchy below.
   if (window != window_.get() && window_->Contains(window))
     return;
 
   UpdateWebContentsVisibility(visible);

[oshima, 2014/09/04 16:39:23]

If we use window_->IsVisible() here, instead of
visible, and can we control visibility by changing the window_'s visibility? 

[Mr4D (OOO till 08-26), 2014/09/04 19:10:57]

Very complicated at this place. 
a. Window_->IsVisible() looks at this window and the chain of parents and their
layers to see if it is visible or not.
b. There are situations (e.g. bubbles in Windows) where turning the
WebContentsView invisible once, it will immediately destroy all its buffers.
When being made visible again, the content does not know its size and the
resulting layer is far too small and garbage is shown until content is loaded.
So in that case for example it should not get hidden - even though it would
follow this. And there are many more special cases like that.
c. I discussed with sky and he said that it would be wrong to control the
resources through the visibility and instead we should listen to the renderer
for resource deallocation messages and trigger from that the preview generation.
Not quite sure how much work that might be.

Anyways - need to do this differently and I will remove this and the logic which
I had put in place to control these states - at least for the most part.

[oshima, 2014/09/04 22:11:01]

Yes, I believe that's what we want in UpdateWebContentsVisibility, and
consistent with
OnWnidowParentChanged.
The current code DOES hide in the scenario you mentioned. The difference that
above change
will make is: when the web content is hidden and parent window (such as top
level) is shown.

 Before: WasShown gets called. 
 After: WasShown won't be called.
I think we just need both signals to manage resources (as we want to do
aggressive resource management).
Sure. Let's leave it for the (hopefully near) future.

[Mr4D (OOO till 08-26), 2014/09/04 22:36:52]

Acknowledged.

 }
 
 void WebContentsViewAura::UpdateWebContentsVisibility(bool visible) {
+#if defined(USE_ATHENA)
+  // In Athena the resources/visibility get controlled by Activities and the
+  // ResourceManager and not the window visibility.

[oshima, 2014/09/03 23:15:00]

have you consult this approach (if def) with content owner?

I have a few concerns here.
1) This probably will break several tests for contents. If we disable them, we
lose coverage.
2) This also can mean things may regress only on athena without being caught by
bots.

I believe that we want to decouple window visibility and web contents
visibility. Is it possible to decouple that way instead?

[Mr4D (OOO till 08-26), 2014/09/04 19:10:57]

We don't do this. I have to come up with a different method to address this
(ensuring that we create an overview image before the layers get released by the
renderer, ..).

+#else
   if (!is_or_was_visible_) {
     // We should not hide the web contents before it was shown the first time,
     // since resources would immediately be destroyed and only re-created after
     // content got loaded. In this state the window content is undefined and can
     // show garbage.
     // However - the page load mechanism requires an activation call through a
     // visibility call to (re)load.
     if (visible) {
       is_or_was_visible_ = true;
       web_contents_->WasShown();
     }
     return;
   }
   if (visible) {
     if (!web_contents_->should_normally_be_visible())
       web_contents_->WasShown();
   } else {
     if (web_contents_->should_normally_be_visible())
       web_contents_->WasHidden();
   }
+#endif
 }
 
 }  // namespace content