TabContentsWrapper -> TabContents, part 41.

chrome/browser/ui/gtk/tabs/dragged_tab_controller_gtk.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/gtk/tabs/dragged_tab_controller_gtk.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/rtl.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/ui/app_modal_dialogs/javascript_dialog_creator.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/tabs/dragged_view_gtk.h"
 #include "chrome/browser/ui/gtk/tabs/tab_strip_gtk.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/base/gtk/gtk_screen_util.h"
 #include "ui/gfx/screen.h"
 
 using content::OpenURLParams;
 using content::WebContents;
 
@@ skipping 53 matching lines @@
   drag_data_.reset();
 }
 
 void DraggedTabControllerGtk::CaptureDragInfo(const gfx::Point& mouse_offset) {
   start_screen_point_ = gfx::Screen::GetCursorScreenPoint();
   mouse_offset_ = mouse_offset;
 }
 
 void DraggedTabControllerGtk::Drag() {
   if (!drag_data_->GetSourceTabData()->tab_ ||
-      !drag_data_->GetSourceTabContentsWrapper() ||
+      !drag_data_->GetSourceTabContents() ||
       !drag_data_->GetSourceWebContents()) {
     return;
   }
 
   bring_to_front_timer_.Stop();
 
   EnsureDraggedView();
 
   // Before we get to dragging anywhere, ensure that we consider ourselves
   // attached to the source tabstrip.
@@ skipping 24 matching lines @@
 
 bool DraggedTabControllerGtk::IsDraggingTab(const TabGtk* tab) {
   for (size_t i = 0; i < drag_data_->size(); i++) {
     if (tab == drag_data_->get(i)->tab_)
       return true;
   }
   return false;
 }
 
 bool DraggedTabControllerGtk::IsDraggingTabContents(
-    const TabContentsWrapper* tab_contents) {
+    const TabContents* tab_contents) {
   for (size_t i = 0; i < drag_data_->size(); i++) {
     if (tab_contents == drag_data_->get(i)->contents_)
       return true;
   }
   return false;
 }
 
 bool DraggedTabControllerGtk::IsTabDetached(const TabGtk* tab) {
   return IsDraggingTab(tab) && attached_tabstrip_ == NULL;
 }
 
 DraggedTabData DraggedTabControllerGtk::InitDraggedTabData(TabGtk* tab) {
   int source_model_index = source_tabstrip_->GetIndexOfTab(tab);
-  TabContentsWrapper* contents =
+  TabContents* contents =
       source_tabstrip_->model()->GetTabContentsAt(source_model_index);
   bool pinned = source_tabstrip_->IsTabPinned(tab);
   bool mini = source_tabstrip_->model()->IsMiniTab(source_model_index);
   // We need to be the delegate so we receive messages about stuff,
   // otherwise our dragged_contents() may be replaced and subsequently
   // collected/destroyed while the drag is in process, leading to
   // nasty crashes.
   content::WebContentsDelegate* original_delegate =
       contents->web_contents()->GetDelegate();
   contents->web_contents()->SetDelegate(this);
 
   DraggedTabData dragged_tab_data(tab, contents, original_delegate,
                                   source_model_index, pinned, mini);
   registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED,
-      content::Source<TabContentsWrapper>(dragged_tab_data.contents_));
+      content::Source<TabContents>(dragged_tab_data.contents_));
   return dragged_tab_data;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DraggedTabControllerGtk, content::WebContentsDelegate implementation:
 
 WebContents* DraggedTabControllerGtk::OpenURLFromTab(
     WebContents* source,
     const OpenURLParams& params) {
   if (drag_data_->GetSourceTabData()->original_delegate_) {
@@ skipping 41 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DraggedTabControllerGtk, content::NotificationObserver implementation:
 
 void DraggedTabControllerGtk::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED, type);
-  TabContentsWrapper* destroyed_tab_contents =
-      content::Source<TabContentsWrapper>(source).ptr();
+  TabContents* destroyed_tab_contents =
+      content::Source<TabContents>(source).ptr();
   WebContents* destroyed_web_contents = destroyed_tab_contents->web_contents();
   for (size_t i = 0; i < drag_data_->size(); ++i) {
     if (drag_data_->get(i)->contents_ == destroyed_tab_contents) {
       // One of the tabs we're dragging has been destroyed. Cancel the drag.
       if (destroyed_web_contents->GetDelegate() == this)
         destroyed_web_contents->SetDelegate(NULL);
       drag_data_->get(i)->contents_ = NULL;
       drag_data_->get(i)->original_delegate_ = NULL;
       EndDragImpl(TAB_DESTROYED);
       return;
@@ skipping 40 matching lines @@
   }
 
   if (attached_tabstrip_)
     MoveAttached(screen_point);
   else
     MoveDetached(screen_point);
 }
 
 void DraggedTabControllerGtk::RestoreSelection(TabStripModel* model) {
   for (size_t i = 0; i < drag_data_->size(); ++i) {
-    TabContentsWrapper* contents = drag_data_->get(i)->contents_;
+    TabContents* contents = drag_data_->get(i)->contents_;
     // If a tab is destroyed while dragging contents might be null. See
     // http://crbug.com/115409.
     if (contents != NULL) {
       int index = model->GetIndexOfTabContents(contents);
       CHECK(index != TabStripModel::kNoTab);
       model->AddTabAtToSelection(index);
     }
   }
 }
 
 void DraggedTabControllerGtk::MoveAttached(const gfx::Point& screen_point) {
   DCHECK(attached_tabstrip_);
 
   gfx::Point dragged_view_point = GetDraggedViewPoint(screen_point);
   TabStripModel* attached_model = attached_tabstrip_->model();
 
   std::vector<TabGtk*> tabs(drag_data_->GetDraggedTabs());
 
   // Determine the horizontal move threshold. This is dependent on the width
   // of tabs. The smaller the tabs compared to the standard size, the smaller
   // the threshold.
   double unselected, selected;
   attached_tabstrip_->GetCurrentTabWidths(&unselected, &selected);
   double ratio = unselected / TabGtk::GetStandardSize().width();
   int threshold = static_cast<int>(ratio * kHorizontalMoveThreshold);
 
-  // Update the model, moving the TabContentsWrapper from one index to another.
+  // Update the model, moving the TabContents from one index to another.
   // Do this only if we have moved a minimum distance since the last reorder (to
   // prevent jitter) or if this is the first move and the tabs are not
   // consecutive.
   if (abs(screen_point.x() - last_move_screen_x_) > threshold ||
       (initial_move_ && !AreTabsConsecutive())) {
     if (initial_move_ && !AreTabsConsecutive()) {
       // Making dragged tabs adjacent, this is done only once, if necessary.
       attached_tabstrip_->model()->MoveSelectedTabsTo(
           drag_data_->GetSourceTabData()->source_model_index_ -
               drag_data_->source_tab_index());
@@ skipping 88 matching lines @@
                                           &unselected_width, &selected_width);
 
   GtkWidget* parent_window = gtk_widget_get_parent(
       gtk_widget_get_parent(attached_tabstrip_->tabstrip_.get()));
   gfx::Rect window_bounds = ui::GetWidgetScreenBounds(parent_window);
   dragged_view_->Attach(static_cast<int>(floor(selected_width + 0.5)),
                         TabGtk::GetMiniWidth(), window_bounds.width());
 
   if (attached_dragged_tabs.size() == 0) {
     // There is no tab in |attached_tabstrip| that corresponds to the dragged
-    // TabContentsWrapper. We must now create one.
+    // TabContents. We must now create one.
 
-    // Remove ourselves as the delegate now that the dragged TabContentsWrapper
+    // Remove ourselves as the delegate now that the dragged TabContents
     // is being inserted back into a Browser.
     for (size_t i = 0; i < drag_data_->size(); ++i) {
       drag_data_->get(i)->contents_->web_contents()->SetDelegate(NULL);
       drag_data_->get(i)->original_delegate_ = NULL;
     }
 
-    // Return the TabContentsWrapper to normalcy.
+    // Return the TabContents to normalcy.
     drag_data_->GetSourceWebContents()->SetCapturingContents(false);
 
     // We need to ask the tabstrip we're attached to ensure that the ideal
     // bounds for all its tabs are correctly generated, because the calculation
     // in GetInsertionIndexForDraggedBounds needs them to be to figure out the
     // appropriate insertion index.
     attached_tabstrip_->GenerateIdealBounds();
 
     // Inserting counts as a move. We don't want the tabs to jitter when the
     // user moves the tab immediately after attaching it.
@@ skipping 98 matching lines @@
   }
 
   if (index == -1) {
     if (dragged_bounds_end > right_tab_x)
       index = attached_tabstrip_->GetTabCount();
     else
       index = 0;
   }
 
   TabGtk* tab = GetTabMatchingDraggedContents(
-      attached_tabstrip_, drag_data_->GetSourceTabContentsWrapper());
+      attached_tabstrip_, drag_data_->GetSourceTabContents());
   if (tab == NULL) {
     // If dragged tabs are not attached yet, we don't need to constrain the
     // index.
     return index;
   }
 
   int max_index =
       attached_tabstrip_-> GetTabCount() - static_cast<int>(drag_data_->size());
   return std::max(0, std::min(max_index, index));
 }
@@ skipping 40 matching lines @@
 
 int DraggedTabControllerGtk::NormalizeIndexToAttachedTabStrip(int index) const {
   if (index >= attached_tabstrip_->model_->count())
     return attached_tabstrip_->model_->count() - 1;
   if (index == TabStripModel::kNoTab)
     return 0;
   return index;
 }
 
 TabGtk* DraggedTabControllerGtk::GetTabMatchingDraggedContents(
-    TabStripGtk* tabstrip, TabContentsWrapper* tab_contents) {
+    TabStripGtk* tabstrip, TabContents* tab_contents) {
   int index = tabstrip->model()->GetIndexOfTabContents(tab_contents);
   return index == TabStripModel::kNoTab ? NULL : tabstrip->GetTabAt(index);
 }
 
 std::vector<TabGtk*> DraggedTabControllerGtk::GetTabsMatchingDraggedContents(
     TabStripGtk* tabstrip) {
   std::vector<TabGtk*> dragged_tabs;
   for (size_t i = 0; i < drag_data_->size(); ++i) {
     if (!drag_data_->get(i)->contents_)
       continue;
@@ skipping 119 matching lines @@
   bool destroy_immediately = true;
   if (attached_tabstrip_) {
     // We don't need to do anything other than make the tabs visible again,
     // since the dragged view is going away.
     dragged_view_->AnimateToBounds(GetAnimateBounds(),
         base::Bind(&DraggedTabControllerGtk::OnAnimateToBoundsComplete,
                    base::Unretained(this)));
     destroy_immediately = false;
   } else {
     // Compel the model to construct a new window for the detached
-    // TabContentsWrapper.
+    // TabContents.
     BrowserWindowGtk* window = source_tabstrip_->window();
     gfx::Rect window_bounds = window->GetRestoredBounds();
     window_bounds.set_origin(GetWindowCreatePoint());
     Browser* new_browser =
         source_tabstrip_->model()->delegate()->CreateNewStripWithContents(
             drag_data_->get(0)->contents_,
             window_bounds,
             dock_info_,
             window->IsMaximized());
     TabStripModel* new_model = new_browser->tab_strip_model();
@@ skipping 72 matching lines @@
 }
 
 void DraggedTabControllerGtk::CleanUpDraggedTabs() {
   // If we were attached to the source tabstrip, dragged tabs will be in use. If
   // we were detached or attached to another tabstrip, we can safely remove
   // them and delete them now.
   if (attached_tabstrip_ != source_tabstrip_) {
     for (size_t i = 0; i < drag_data_->size(); ++i) {
       if (drag_data_->get(i)->contents_) {
         registrar_.Remove(this, chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED,
-            content::Source<TabContentsWrapper>(drag_data_->get(i)->contents_));
+            content::Source<TabContents>(drag_data_->get(i)->contents_));
       }
       source_tabstrip_->DestroyDraggedTab(drag_data_->get(i)->tab_);
       drag_data_->get(i)->tab_ = NULL;
     }
   }
 }
 
 void DraggedTabControllerGtk::OnAnimateToBoundsComplete() {
   // Sometimes, for some reason, in automation we can be called back on a
   // detach even though we aren't attached to a tabstrip. Guard against that.
@@ skipping 23 matching lines @@
 
 bool DraggedTabControllerGtk::AreTabsConsecutive() {
   for (size_t i = 1; i < drag_data_->size(); ++i) {
     if (drag_data_->get(i - 1)->source_model_index_ + 1 !=
         drag_data_->get(i)->source_model_index_) {
       return false;
     }
   }
   return true;
 }