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 1122 matching lines @@
 
     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);
+      source_dragged_contents()->DecrementCapturerCount();
     }
 
     // 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 68 matching lines @@
     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);
+    source_dragged_contents()->IncrementCapturerCount();
 
   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.
@@ skipping 413 matching lines @@
     GetModel(source_tabstrip_)->SetSelectionFromModel(initial_selection_model_);
 
   // If we're not attached to any TabStrip, or attached to some other TabStrip,
   // we need to restore the bounds of the original TabStrip's frame, in case
   // it has been hidden.
   if (restore_frame && !restore_bounds_.IsEmpty())
     source_tabstrip_->GetWidget()->SetBounds(restore_bounds_);
 
   if (detach_into_browser_ && source_tabstrip_)
     source_tabstrip_->GetWidget()->Activate();
+
+  // Return the WebContents to normalcy.  If the tab was attached to a
+  // TabStrip before the revert, the decrement has already occurred.
+  // If the tab was destroyed, don't attempt to dereference the
+  // WebContents pointer.
+  if (!detach_into_browser_ && !attached_tabstrip_ && source_dragged_contents())
+    source_dragged_contents()->DecrementCapturerCount();
 }
 
 void TabDragController::ResetSelection(TabStripModel* model) {
   DCHECK(model);
   ui::ListSelectionModel selection_model;
   bool has_one_valid_tab = false;
   for (size_t i = 0; i < drag_data_.size(); ++i) {
     // |contents| is NULL if a tab was deleted out from under us.
     if (drag_data_[i].contents) {
       int index = model->GetIndexOfWebContents(drag_data_[i].contents);
@@ skipping 125 matching lines @@
       item.add_types = drag_data_[i].pinned ? TabStripModel::ADD_PINNED
                                             : TabStripModel::ADD_NONE;
       contentses.push_back(item);
     };
 
     Browser* new_browser =
         GetModel(source_tabstrip_)->delegate()->CreateNewStripWithContents(
             contentses, window_bounds, dock_info_, widget->IsMaximized());
     ResetSelection(new_browser->tab_strip_model());
     new_browser->window()->Show();
+
+    // Return the WebContents to normalcy.
+    if (!detach_into_browser_)
+      source_dragged_contents()->DecrementCapturerCount();
   }
 
   CleanUpHiddenFrame();
 }
 
 void TabDragController::ResetDelegates() {
   DCHECK(!detach_into_browser_);
   for (size_t i = 0; i < drag_data_.size(); ++i) {
     if (drag_data_[i].contents &&
         drag_data_[i].contents->GetDelegate() == this) {
@@ skipping 223 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();
 }