While screencasting a tab, do not disable rendering updates while hidden.

chrome/browser/ui/views/tabs/tab_drag_controller.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 "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/auto_reset.h"
@@ skipping 471 matching lines @@
   move_stacked_timer_.Stop();
 
   if (waiting_for_run_loop_to_exit_)
     return;
 
   if (!started_drag_) {
     if (!CanStartDrag(point_in_screen))
       return;  // User hasn't dragged far enough yet.
 
     started_drag_ = true;
+    // Prevent the WebContents HWND from being hidden by any of the model
+    // operations performed during the drag.
+    source_dragged_contents()->SetCapturingContents(true);

[sky, 2013/02/04 15:02:25]

At this point the tab is very likely still in the tabstrip. You should only need
to set this once the tab has been detached (where this call was before). What
made you need to move it?

[miu, 2013/02/04 21:36:52]

Short story: It's the simplest solution that fixes the bug (mentioned in the
descr.) and avoids adding a lot of extra complicated logic to TabDragController.

In more detail, the bug is this: After a tab is detached during a drag, there
are multiple scenarios where Attach() will not be called after the drag has
ended.  This is bad because SetCapturingContents(false) won't be called. 
Example scenarios:

1. Whenever you detach a tab from the tab strip, and then release it such that
it creates a new browser window for itself.

2. Whenever you detach a tab from the tab strip, and then hit the Escape key.

So, I spent a lot of time looking for a way to correct these problems, but I was
adding a *lot* of complicated logic to TabDragController to handle all the edge
cases.  Furthermore, I felt it would be way too easy for a bug regression to
occur when future logic changes are made by others.

Therefore, I turned to looking for the single code path that is always executed
on drag start (and on stop).  While you're correct in that we only *need* to
call SetCapturingContents(true) once the tab has been detached, it's perfectly
harmless to call it right at the start of the drag.  IMHO, the code is so much
cleaner this way.

[sky, 2013/02/04 22:48:50]

None-the-less it's the *wrong* state. The tab is not yet detached. Additionally
if you have live tab dragging on (as aura does), the method shouldn't be
invoked.
TabDragController should have code paths the deal with all the case you care
about. Those cases should be fixed to do the right thing.

[miu, 2013/02/05 01:06:25]

Fixed.  This was all a bit confusing to me.  Would have been nice if the Aura
behavior was a separate TabDragController implementation entirely, since a lot
of concepts/assumptions are different.
Done.  My changes to TabDragController are only to fix exactly the cases that
were broken.  And, it goes without saying that I've extensively re-tested all of
this to make sure.  ;-)

     SaveFocus();
     Attach(source_tabstrip_, gfx::Point());
     if (detach_into_browser_ && static_cast<int>(drag_data_.size()) ==
         GetModel(source_tabstrip_)->count()) {
       RunMoveLoop(GetWindowOffset(point_in_screen));
       return;
     }
   }
 
   ContinueDragging(point_in_screen);
@@ skipping 626 matching lines @@
 
     selection_model_before_attach_.Copy(attached_tabstrip->GetSelectionModel());
 
     if (!detach_into_browser_) {
       // Remove ourselves as the delegate now that the dragged WebContents is
       // being inserted back into a Browser.
       for (size_t i = 0; i < drag_data_.size(); ++i) {
         drag_data_[i].contents->SetDelegate(NULL);
         drag_data_[i].original_delegate = NULL;
       }
-
-      // Return the WebContents to normalcy.
-      source_dragged_contents()->SetCapturingContents(false);
     }
 
     // Inserting counts as a move. We don't want the tabs to jitter when the
     // user moves the tab immediately after attaching it.
     last_move_screen_loc_ = point_in_screen.x();
 
     // Figure out where to insert the tab based on the bounds of the dragged
     // representation and the ideal bounds of the other Tabs already in the
     // strip. ("ideal bounds" are stable even if the Tabs' actual bounds are
     // changing due to animation).
@@ skipping 65 matching lines @@
   // Release ownership of the drag controller and mouse capture. When we
   // reattach ownership is transfered.
   if (detach_into_browser_) {
     attached_tabstrip_->ReleaseDragController();
     if (release_capture == RELEASE_CAPTURE)
       attached_tabstrip_->GetWidget()->ReleaseCapture();
   }
 
   mouse_move_direction_ = kMovedMouseLeft | kMovedMouseRight;
 
-  // Prevent the WebContents HWND from being hidden by any of the model
-  // operations performed during the drag.
-  if (!detach_into_browser_)
-    source_dragged_contents()->SetCapturingContents(true);
-
   std::vector<gfx::Rect> drag_bounds = CalculateBoundsForDraggedTabs(0);
   TabStripModel* attached_model = GetModel(attached_tabstrip_);
   std::vector<TabRendererData> tab_data;
   for (size_t i = 0; i < drag_data_.size(); ++i) {
     tab_data.push_back(drag_data_[i].attached_tab->data());
     int index = attached_model->GetIndexOfWebContents(drag_data_[i].contents);
     DCHECK_NE(-1, index);
 
     // Hide the tab so that the user doesn't see it animate closed.
     drag_data_[i].attached_tab->SetVisible(false);
@@ skipping 357 matching lines @@
   }
   dock_controllers_.clear();
   dock_windows_.clear();
 
   if (type != TAB_DESTROYED) {
     // We only finish up the drag if we were actually dragging. If start_drag_
     // is false, the user just clicked and released and didn't move the mouse
     // enough to trigger a drag.
     if (started_drag_) {
       RestoreFocus();
+      source_dragged_contents()->SetCapturingContents(false);
       if (type == CANCELED)
         RevertDrag();
       else
         CompleteDrag();
     }
   } else if (drag_data_.size() > 1) {
     RevertDrag();
   }  // else case the only tab we were dragging was deleted. Nothing to do.
 
   if (!detach_into_browser_)
@@ skipping 423 matching lines @@
 gfx::Vector2d TabDragController::GetWindowOffset(
     const gfx::Point& point_in_screen) {
   TabStrip* owning_tabstrip = (attached_tabstrip_ && detach_into_browser_) ?
       attached_tabstrip_ : source_tabstrip_;
   views::View* toplevel_view = owning_tabstrip->GetWidget()->GetContentsView();
 
   gfx::Point point = point_in_screen;
   views::View::ConvertPointFromScreen(toplevel_view, &point);
   return point.OffsetFromOrigin();
 }