1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/ui/tabs/tab_strip_model.h" 6 7 #include <algorithm> 8 #include <map> 9 #include <string> 10 11 #include "apps/ui/web_contents_sizer.h" 12 #include "base/metrics/histogram.h" 13 #include "base/stl_util.h" 14 #include "chrome/app/chrome_command_ids.h" 15 #include "chrome/browser/browser_shutdown.h" 16 #include "chrome/browser/defaults.h" 17 #include "chrome/browser/extensions/tab_helper.h" 18 #include "chrome/browser/profiles/profile.h" 19 #include "chrome/browser/ui/tab_contents/core_tab_helper.h" 20 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h" 21 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h" 22 #include "chrome/browser/ui/tabs/tab_strip_model_order_controller.h" 23 #include "chrome/common/url_constants.h" 24 #include "components/web_modal/web_contents_modal_dialog_manager.h" 25 #include "content/public/browser/render_process_host.h" 26 #include "content/public/browser/user_metrics.h" 27 #include "content/public/browser/web_contents.h" 28 #include "content/public/browser/web_contents_observer.h" 29 using base::UserMetricsAction; 30 using content::WebContents; 31 32 namespace { 33 34 // Returns true if the specified transition is one of the types that cause the 35 // opener relationships for the tab in which the transition occurred to be 36 // forgotten. This is generally any navigation that isn't a link click (i.e. 37 // any navigation that can be considered to be the start of a new task distinct 38 // from what had previously occurred in that tab). 39 bool ShouldForgetOpenersForTransition(content::PageTransition transition) { 40 return transition == content::PAGE_TRANSITION_TYPED || 41 transition == content::PAGE_TRANSITION_AUTO_BOOKMARK || 42 transition == content::PAGE_TRANSITION_GENERATED || 43 transition == content::PAGE_TRANSITION_KEYWORD || 44 transition == content::PAGE_TRANSITION_AUTO_TOPLEVEL; 45 } 46 47 // CloseTracker is used when closing a set of WebContents. It listens for 48 // deletions of the WebContents and removes from the internal set any time one 49 // is deleted. 50 class CloseTracker { 51 public: 52 typedef std::vector<WebContents*> Contents; 53 54 explicit CloseTracker(const Contents& contents); 55 virtual ~CloseTracker(); 56 57 // Returns true if there is another WebContents in the Tracker. 58 bool HasNext() const; 59 60 // Returns the next WebContents, or NULL if there are no more. 61 WebContents* Next(); 62 63 private: 64 class DeletionObserver : public content::WebContentsObserver { 65 public: 66 DeletionObserver(CloseTracker* parent, WebContents* web_contents) 67 : WebContentsObserver(web_contents), 68 parent_(parent) { 69 } 70 71 // Expose web_contents() publicly. 72 using content::WebContentsObserver::web_contents; 73 74 private: 75 // WebContentsObserver: 76 virtual void WebContentsDestroyed() OVERRIDE { 77 parent_->OnWebContentsDestroyed(this); 78 } 79 80 CloseTracker* parent_; 81 82 DISALLOW_COPY_AND_ASSIGN(DeletionObserver); 83 }; 84 85 void OnWebContentsDestroyed(DeletionObserver* observer); 86 87 typedef std::vector<DeletionObserver*> Observers; 88 Observers observers_; 89 90 DISALLOW_COPY_AND_ASSIGN(CloseTracker); 91 }; 92 93 CloseTracker::CloseTracker(const Contents& contents) { 94 for (size_t i = 0; i < contents.size(); ++i) 95 observers_.push_back(new DeletionObserver(this, contents[i])); 96 } 97 98 CloseTracker::~CloseTracker() { 99 DCHECK(observers_.empty()); 100 } 101 102 bool CloseTracker::HasNext() const { 103 return !observers_.empty(); 104 } 105 106 WebContents* CloseTracker::Next() { 107 if (observers_.empty()) 108 return NULL; 109 110 DeletionObserver* observer = observers_[0]; 111 WebContents* web_contents = observer->web_contents(); 112 observers_.erase(observers_.begin()); 113 delete observer; 114 return web_contents; 115 } 116 117 void CloseTracker::OnWebContentsDestroyed(DeletionObserver* observer) { 118 Observers::iterator i = 119 std::find(observers_.begin(), observers_.end(), observer); 120 if (i != observers_.end()) { 121 delete *i; 122 observers_.erase(i); 123 return; 124 } 125 NOTREACHED() << "WebContents destroyed that wasn't in the list"; 126 } 127 128 } // namespace 129 130 /////////////////////////////////////////////////////////////////////////////// 131 // WebContentsData 132 133 // An object to hold a reference to a WebContents that is in a tabstrip, as 134 // well as other various properties it has. 135 class TabStripModel::WebContentsData : public content::WebContentsObserver { 136 public: 137 WebContentsData(TabStripModel* tab_strip_model, WebContents* a_contents); 138 139 // Changes the WebContents that this WebContentsData tracks. 140 void SetWebContents(WebContents* contents); 141 WebContents* web_contents() { return contents_; } 142 143 // Create a relationship between this WebContentsData and other 144 // WebContentses. Used to identify which WebContents to select next after 145 // one is closed. 146 WebContents* group() const { return group_; } 147 void set_group(WebContents* value) { group_ = value; } 148 WebContents* opener() const { return opener_; } 149 void set_opener(WebContents* value) { opener_ = value; } 150 151 // Alters the properties of the WebContents. 152 bool reset_group_on_select() const { return reset_group_on_select_; } 153 void set_reset_group_on_select(bool value) { reset_group_on_select_ = value; } 154 bool pinned() const { return pinned_; } 155 void set_pinned(bool value) { pinned_ = value; } 156 bool blocked() const { return blocked_; } 157 void set_blocked(bool value) { blocked_ = value; } 158 bool discarded() const { return discarded_; } 159 void set_discarded(bool value) { discarded_ = value; } 160 161 private: 162 // Make sure that if someone deletes this WebContents out from under us, it 163 // is properly removed from the tab strip. 164 virtual void WebContentsDestroyed() OVERRIDE; 165 166 // The WebContents being tracked by this WebContentsData. The 167 // WebContentsObserver does keep a reference, but when the WebContents is 168 // deleted, the WebContentsObserver reference is NULLed and thus inaccessible. 169 WebContents* contents_; 170 171 // The TabStripModel containing this WebContents. 172 TabStripModel* tab_strip_model_; 173 174 // The group is used to model a set of tabs spawned from a single parent 175 // tab. This value is preserved for a given tab as long as the tab remains 176 // navigated to the link it was initially opened at or some navigation from 177 // that page (i.e. if the user types or visits a bookmark or some other 178 // navigation within that tab, the group relationship is lost). This 179 // property can safely be used to implement features that depend on a 180 // logical group of related tabs. 181 WebContents* group_; 182 183 // The owner models the same relationship as group, except it is more 184 // easily discarded, e.g. when the user switches to a tab not part of the 185 // same group. This property is used to determine what tab to select next 186 // when one is closed. 187 WebContents* opener_; 188 189 // True if our group should be reset the moment selection moves away from 190 // this tab. This is the case for tabs opened in the foreground at the end 191 // of the TabStrip while viewing another Tab. If these tabs are closed 192 // before selection moves elsewhere, their opener is selected. But if 193 // selection shifts to _any_ tab (including their opener), the group 194 // relationship is reset to avoid confusing close sequencing. 195 bool reset_group_on_select_; 196 197 // Is the tab pinned? 198 bool pinned_; 199 200 // Is the tab interaction blocked by a modal dialog? 201 bool blocked_; 202 203 // Has the tab data been discarded to save memory? 204 bool discarded_; 205 206 DISALLOW_COPY_AND_ASSIGN(WebContentsData); 207 }; 208 209 TabStripModel::WebContentsData::WebContentsData(TabStripModel* tab_strip_model, 210 WebContents* contents) 211 : content::WebContentsObserver(contents), 212 contents_(contents), 213 tab_strip_model_(tab_strip_model), 214 group_(NULL), 215 opener_(NULL), 216 reset_group_on_select_(false), 217 pinned_(false), 218 blocked_(false), 219 discarded_(false) { 220 } 221 222 void TabStripModel::WebContentsData::SetWebContents(WebContents* contents) { 223 contents_ = contents; 224 Observe(contents); 225 } 226 227 void TabStripModel::WebContentsData::WebContentsDestroyed() { 228 DCHECK_EQ(contents_, web_contents()); 229 230 // Note that we only detach the contents here, not close it - it's 231 // already been closed. We just want to undo our bookkeeping. 232 int index = tab_strip_model_->GetIndexOfWebContents(web_contents()); 233 DCHECK_NE(TabStripModel::kNoTab, index); 234 tab_strip_model_->DetachWebContentsAt(index); 235 } 236 237 /////////////////////////////////////////////////////////////////////////////// 238 // TabStripModel, public: 239 240 TabStripModel::TabStripModel(TabStripModelDelegate* delegate, Profile* profile) 241 : delegate_(delegate), 242 profile_(profile), 243 closing_all_(false), 244 in_notify_(false), 245 weak_factory_(this) { 246 DCHECK(delegate_); 247 order_controller_.reset(new TabStripModelOrderController(this)); 248 } 249 250 TabStripModel::~TabStripModel() { 251 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 252 TabStripModelDeleted()); 253 STLDeleteElements(&contents_data_); 254 order_controller_.reset(); 255 } 256 257 void TabStripModel::AddObserver(TabStripModelObserver* observer) { 258 observers_.AddObserver(observer); 259 } 260 261 void TabStripModel::RemoveObserver(TabStripModelObserver* observer) { 262 observers_.RemoveObserver(observer); 263 } 264 265 bool TabStripModel::ContainsIndex(int index) const { 266 return index >= 0 && index < count(); 267 } 268 269 void TabStripModel::AppendWebContents(WebContents* contents, 270 bool foreground) { 271 InsertWebContentsAt(count(), contents, 272 foreground ? (ADD_INHERIT_GROUP | ADD_ACTIVE) : 273 ADD_NONE); 274 } 275 276 void TabStripModel::InsertWebContentsAt(int index, 277 WebContents* contents, 278 int add_types) { 279 delegate_->WillAddWebContents(contents); 280 281 bool active = add_types & ADD_ACTIVE; 282 // Force app tabs to be pinned. 283 extensions::TabHelper* extensions_tab_helper = 284 extensions::TabHelper::FromWebContents(contents); 285 bool pin = extensions_tab_helper->is_app() || add_types & ADD_PINNED; 286 index = ConstrainInsertionIndex(index, pin); 287 288 // In tab dragging situations, if the last tab in the window was detached 289 // then the user aborted the drag, we will have the |closing_all_| member 290 // set (see DetachWebContentsAt) which will mess with our mojo here. We need 291 // to clear this bit. 292 closing_all_ = false; 293 294 // Have to get the active contents before we monkey with the contents 295 // otherwise we run into problems when we try to change the active contents 296 // since the old contents and the new contents will be the same... 297 WebContents* active_contents = GetActiveWebContents(); 298 WebContentsData* data = new WebContentsData(this, contents); 299 data->set_pinned(pin); 300 if ((add_types & ADD_INHERIT_GROUP) && active_contents) { 301 if (active) { 302 // Forget any existing relationships, we don't want to make things too 303 // confusing by having multiple groups active at the same time. 304 ForgetAllOpeners(); 305 } 306 // Anything opened by a link we deem to have an opener. 307 data->set_group(active_contents); 308 data->set_opener(active_contents); 309 } else if ((add_types & ADD_INHERIT_OPENER) && active_contents) { 310 if (active) { 311 // Forget any existing relationships, we don't want to make things too 312 // confusing by having multiple groups active at the same time. 313 ForgetAllOpeners(); 314 } 315 data->set_opener(active_contents); 316 } 317 318 web_modal::WebContentsModalDialogManager* modal_dialog_manager = 319 web_modal::WebContentsModalDialogManager::FromWebContents(contents); 320 if (modal_dialog_manager) 321 data->set_blocked(modal_dialog_manager->IsDialogActive()); 322 323 contents_data_.insert(contents_data_.begin() + index, data); 324 325 selection_model_.IncrementFrom(index); 326 327 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 328 TabInsertedAt(contents, index, active)); 329 if (active) { 330 ui::ListSelectionModel new_model; 331 new_model.Copy(selection_model_); 332 new_model.SetSelectedIndex(index); 333 SetSelection(new_model, NOTIFY_DEFAULT); 334 } 335 } 336 337 WebContents* TabStripModel::ReplaceWebContentsAt(int index, 338 WebContents* new_contents) { 339 delegate_->WillAddWebContents(new_contents); 340 341 DCHECK(ContainsIndex(index)); 342 WebContents* old_contents = GetWebContentsAtImpl(index); 343 344 ForgetOpenersAndGroupsReferencing(old_contents); 345 346 contents_data_[index]->SetWebContents(new_contents); 347 348 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 349 TabReplacedAt(this, old_contents, new_contents, index)); 350 351 // When the active WebContents is replaced send out a selection notification 352 // too. We do this as nearly all observers need to treat a replacement of the 353 // selected contents as the selection changing. 354 if (active_index() == index) { 355 FOR_EACH_OBSERVER( 356 TabStripModelObserver, 357 observers_, 358 ActiveTabChanged(old_contents, 359 new_contents, 360 active_index(), 361 TabStripModelObserver::CHANGE_REASON_REPLACED)); 362 } 363 return old_contents; 364 } 365 366 WebContents* TabStripModel::DiscardWebContentsAt(int index) { 367 DCHECK(ContainsIndex(index)); 368 // Do not discard active tab. 369 if (active_index() == index) 370 return NULL; 371 372 WebContents* null_contents = 373 WebContents::Create(WebContents::CreateParams(profile())); 374 WebContents* old_contents = GetWebContentsAtImpl(index); 375 // Copy over the state from the navigation controller so we preserve the 376 // back/forward history and continue to display the correct title/favicon. 377 null_contents->GetController().CopyStateFrom(old_contents->GetController()); 378 // Replace the tab we're discarding with the null version. 379 ReplaceWebContentsAt(index, null_contents); 380 // Mark the tab so it will reload when we click. 381 contents_data_[index]->set_discarded(true); 382 // Discard the old tab's renderer. 383 // TODO(jamescook): This breaks script connections with other tabs. 384 // We need to find a different approach that doesn't do that, perhaps based 385 // on navigation to swappedout://. 386 delete old_contents; 387 return null_contents; 388 } 389 390 WebContents* TabStripModel::DetachWebContentsAt(int index) { 391 CHECK(!in_notify_); 392 if (contents_data_.empty()) 393 return NULL; 394 395 DCHECK(ContainsIndex(index)); 396 397 WebContents* removed_contents = GetWebContentsAtImpl(index); 398 bool was_selected = IsTabSelected(index); 399 int next_selected_index = order_controller_->DetermineNewSelectedIndex(index); 400 delete contents_data_[index]; 401 contents_data_.erase(contents_data_.begin() + index); 402 ForgetOpenersAndGroupsReferencing(removed_contents); 403 if (empty()) 404 closing_all_ = true; 405 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 406 TabDetachedAt(removed_contents, index)); 407 if (empty()) { 408 selection_model_.Clear(); 409 // TabDetachedAt() might unregister observers, so send |TabStripEmpty()| in 410 // a second pass. 411 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, TabStripEmpty()); 412 } else { 413 int old_active = active_index(); 414 selection_model_.DecrementFrom(index); 415 ui::ListSelectionModel old_model; 416 old_model.Copy(selection_model_); 417 if (index == old_active) { 418 NotifyIfTabDeactivated(removed_contents); 419 if (!selection_model_.empty()) { 420 // The active tab was removed, but there is still something selected. 421 // Move the active and anchor to the first selected index. 422 selection_model_.set_active(selection_model_.selected_indices()[0]); 423 selection_model_.set_anchor(selection_model_.active()); 424 } else { 425 // The active tab was removed and nothing is selected. Reset the 426 // selection and send out notification. 427 selection_model_.SetSelectedIndex(next_selected_index); 428 } 429 NotifyIfActiveTabChanged(removed_contents, NOTIFY_DEFAULT); 430 } 431 432 // Sending notification in case the detached tab was selected. Using 433 // NotifyIfActiveOrSelectionChanged() here would not guarantee that a 434 // notification is sent even though the tab selection has changed because 435 // |old_model| is stored after calling DecrementFrom(). 436 if (was_selected) { 437 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 438 TabSelectionChanged(this, old_model)); 439 } 440 } 441 return removed_contents; 442 } 443 444 void TabStripModel::ActivateTabAt(int index, bool user_gesture) { 445 DCHECK(ContainsIndex(index)); 446 ui::ListSelectionModel new_model; 447 new_model.Copy(selection_model_); 448 new_model.SetSelectedIndex(index); 449 SetSelection(new_model, user_gesture ? NOTIFY_USER_GESTURE : NOTIFY_DEFAULT); 450 } 451 452 void TabStripModel::AddTabAtToSelection(int index) { 453 DCHECK(ContainsIndex(index)); 454 ui::ListSelectionModel new_model; 455 new_model.Copy(selection_model_); 456 new_model.AddIndexToSelection(index); 457 SetSelection(new_model, NOTIFY_DEFAULT); 458 } 459 460 void TabStripModel::MoveWebContentsAt(int index, 461 int to_position, 462 bool select_after_move) { 463 DCHECK(ContainsIndex(index)); 464 if (index == to_position) 465 return; 466 467 int first_non_mini_tab = IndexOfFirstNonMiniTab(); 468 if ((index < first_non_mini_tab && to_position >= first_non_mini_tab) || 469 (to_position < first_non_mini_tab && index >= first_non_mini_tab)) { 470 // This would result in mini tabs mixed with non-mini tabs. We don't allow 471 // that. 472 return; 473 } 474 475 MoveWebContentsAtImpl(index, to_position, select_after_move); 476 } 477 478 void TabStripModel::MoveSelectedTabsTo(int index) { 479 int total_mini_count = IndexOfFirstNonMiniTab(); 480 int selected_mini_count = 0; 481 int selected_count = 482 static_cast<int>(selection_model_.selected_indices().size()); 483 for (int i = 0; i < selected_count && 484 IsMiniTab(selection_model_.selected_indices()[i]); ++i) { 485 selected_mini_count++; 486 } 487 488 // To maintain that all mini-tabs occur before non-mini-tabs we move them 489 // first. 490 if (selected_mini_count > 0) { 491 MoveSelectedTabsToImpl( 492 std::min(total_mini_count - selected_mini_count, index), 0u, 493 selected_mini_count); 494 if (index > total_mini_count - selected_mini_count) { 495 // We're being told to drag mini-tabs to an invalid location. Adjust the 496 // index such that non-mini-tabs end up at a location as though we could 497 // move the mini-tabs to index. See description in header for more 498 // details. 499 index += selected_mini_count; 500 } 501 } 502 if (selected_mini_count == selected_count) 503 return; 504 505 // Then move the non-pinned tabs. 506 MoveSelectedTabsToImpl(std::max(index, total_mini_count), 507 selected_mini_count, 508 selected_count - selected_mini_count); 509 } 510 511 WebContents* TabStripModel::GetActiveWebContents() const { 512 return GetWebContentsAt(active_index()); 513 } 514 515 WebContents* TabStripModel::GetWebContentsAt(int index) const { 516 if (ContainsIndex(index)) 517 return GetWebContentsAtImpl(index); 518 return NULL; 519 } 520 521 int TabStripModel::GetIndexOfWebContents(const WebContents* contents) const { 522 for (size_t i = 0; i < contents_data_.size(); ++i) { 523 if (contents_data_[i]->web_contents() == contents) 524 return i; 525 } 526 return kNoTab; 527 } 528 529 void TabStripModel::UpdateWebContentsStateAt(int index, 530 TabStripModelObserver::TabChangeType change_type) { 531 DCHECK(ContainsIndex(index)); 532 533 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 534 TabChangedAt(GetWebContentsAtImpl(index), index, change_type)); 535 } 536 537 void TabStripModel::CloseAllTabs() { 538 // Set state so that observers can adjust their behavior to suit this 539 // specific condition when CloseWebContentsAt causes a flurry of 540 // Close/Detach/Select notifications to be sent. 541 closing_all_ = true; 542 std::vector<int> closing_tabs; 543 for (int i = count() - 1; i >= 0; --i) 544 closing_tabs.push_back(i); 545 InternalCloseTabs(closing_tabs, CLOSE_CREATE_HISTORICAL_TAB); 546 } 547 548 bool TabStripModel::CloseWebContentsAt(int index, uint32 close_types) { 549 DCHECK(ContainsIndex(index)); 550 std::vector<int> closing_tabs; 551 closing_tabs.push_back(index); 552 return InternalCloseTabs(closing_tabs, close_types); 553 } 554 555 bool TabStripModel::TabsAreLoading() const { 556 for (WebContentsDataVector::const_iterator iter = contents_data_.begin(); 557 iter != contents_data_.end(); ++iter) { 558 if ((*iter)->web_contents()->IsLoading()) 559 return true; 560 } 561 return false; 562 } 563 564 WebContents* TabStripModel::GetOpenerOfWebContentsAt(int index) { 565 DCHECK(ContainsIndex(index)); 566 return contents_data_[index]->opener(); 567 } 568 569 void TabStripModel::SetOpenerOfWebContentsAt(int index, 570 WebContents* opener) { 571 DCHECK(ContainsIndex(index)); 572 DCHECK(opener); 573 contents_data_[index]->set_opener(opener); 574 } 575 576 int TabStripModel::GetIndexOfNextWebContentsOpenedBy(const WebContents* opener, 577 int start_index, 578 bool use_group) const { 579 DCHECK(opener); 580 DCHECK(ContainsIndex(start_index)); 581 582 // Check tabs after start_index first. 583 for (int i = start_index + 1; i < count(); ++i) { 584 if (OpenerMatches(contents_data_[i], opener, use_group)) 585 return i; 586 } 587 // Then check tabs before start_index, iterating backwards. 588 for (int i = start_index - 1; i >= 0; --i) { 589 if (OpenerMatches(contents_data_[i], opener, use_group)) 590 return i; 591 } 592 return kNoTab; 593 } 594 595 int TabStripModel::GetIndexOfLastWebContentsOpenedBy(const WebContents* opener, 596 int start_index) const { 597 DCHECK(opener); 598 DCHECK(ContainsIndex(start_index)); 599 600 for (int i = contents_data_.size() - 1; i > start_index; --i) { 601 if (contents_data_[i]->opener() == opener) 602 return i; 603 } 604 return kNoTab; 605 } 606 607 void TabStripModel::TabNavigating(WebContents* contents, 608 content::PageTransition transition) { 609 if (ShouldForgetOpenersForTransition(transition)) { 610 // Don't forget the openers if this tab is a New Tab page opened at the 611 // end of the TabStrip (e.g. by pressing Ctrl+T). Give the user one 612 // navigation of one of these transition types before resetting the 613 // opener relationships (this allows for the use case of opening a new 614 // tab to do a quick look-up of something while viewing a tab earlier in 615 // the strip). We can make this heuristic more permissive if need be. 616 if (!IsNewTabAtEndOfTabStrip(contents)) { 617 // If the user navigates the current tab to another page in any way 618 // other than by clicking a link, we want to pro-actively forget all 619 // TabStrip opener relationships since we assume they're beginning a 620 // different task by reusing the current tab. 621 ForgetAllOpeners(); 622 // In this specific case we also want to reset the group relationship, 623 // since it is now technically invalid. 624 ForgetGroup(contents); 625 } 626 } 627 } 628 629 void TabStripModel::ForgetAllOpeners() { 630 // Forget all opener memories so we don't do anything weird with tab 631 // re-selection ordering. 632 for (WebContentsDataVector::const_iterator iter = contents_data_.begin(); 633 iter != contents_data_.end(); ++iter) 634 (*iter)->set_opener(NULL); 635 } 636 637 void TabStripModel::ForgetGroup(WebContents* contents) { 638 int index = GetIndexOfWebContents(contents); 639 DCHECK(ContainsIndex(index)); 640 contents_data_[index]->set_group(NULL); 641 contents_data_[index]->set_opener(NULL); 642 } 643 644 bool TabStripModel::ShouldResetGroupOnSelect(WebContents* contents) const { 645 int index = GetIndexOfWebContents(contents); 646 DCHECK(ContainsIndex(index)); 647 return contents_data_[index]->reset_group_on_select(); 648 } 649 650 void TabStripModel::SetTabBlocked(int index, bool blocked) { 651 DCHECK(ContainsIndex(index)); 652 if (contents_data_[index]->blocked() == blocked) 653 return; 654 contents_data_[index]->set_blocked(blocked); 655 FOR_EACH_OBSERVER( 656 TabStripModelObserver, observers_, 657 TabBlockedStateChanged(contents_data_[index]->web_contents(), 658 index)); 659 } 660 661 void TabStripModel::SetTabPinned(int index, bool pinned) { 662 DCHECK(ContainsIndex(index)); 663 if (contents_data_[index]->pinned() == pinned) 664 return; 665 666 if (IsAppTab(index)) { 667 if (!pinned) { 668 // App tabs should always be pinned. 669 NOTREACHED(); 670 return; 671 } 672 // Changing the pinned state of an app tab doesn't affect its mini-tab 673 // status. 674 contents_data_[index]->set_pinned(pinned); 675 } else { 676 // The tab is not an app tab, its position may have to change as the 677 // mini-tab state is changing. 678 int non_mini_tab_index = IndexOfFirstNonMiniTab(); 679 contents_data_[index]->set_pinned(pinned); 680 if (pinned && index != non_mini_tab_index) { 681 MoveWebContentsAtImpl(index, non_mini_tab_index, false); 682 index = non_mini_tab_index; 683 } else if (!pinned && index + 1 != non_mini_tab_index) { 684 MoveWebContentsAtImpl(index, non_mini_tab_index - 1, false); 685 index = non_mini_tab_index - 1; 686 } 687 688 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 689 TabMiniStateChanged(contents_data_[index]->web_contents(), 690 index)); 691 } 692 693 // else: the tab was at the boundary and its position doesn't need to change. 694 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 695 TabPinnedStateChanged(contents_data_[index]->web_contents(), 696 index)); 697 } 698 699 bool TabStripModel::IsTabPinned(int index) const { 700 DCHECK(ContainsIndex(index)); 701 return contents_data_[index]->pinned(); 702 } 703 704 bool TabStripModel::IsMiniTab(int index) const { 705 return IsTabPinned(index) || IsAppTab(index); 706 } 707 708 bool TabStripModel::IsAppTab(int index) const { 709 WebContents* contents = GetWebContentsAt(index); 710 return contents && extensions::TabHelper::FromWebContents(contents)->is_app(); 711 } 712 713 bool TabStripModel::IsTabBlocked(int index) const { 714 return contents_data_[index]->blocked(); 715 } 716 717 bool TabStripModel::IsTabDiscarded(int index) const { 718 return contents_data_[index]->discarded(); 719 } 720 721 int TabStripModel::IndexOfFirstNonMiniTab() const { 722 for (size_t i = 0; i < contents_data_.size(); ++i) { 723 if (!IsMiniTab(static_cast<int>(i))) 724 return static_cast<int>(i); 725 } 726 // No mini-tabs. 727 return count(); 728 } 729 730 int TabStripModel::ConstrainInsertionIndex(int index, bool mini_tab) { 731 return mini_tab ? std::min(std::max(0, index), IndexOfFirstNonMiniTab()) : 732 std::min(count(), std::max(index, IndexOfFirstNonMiniTab())); 733 } 734 735 void TabStripModel::ExtendSelectionTo(int index) { 736 DCHECK(ContainsIndex(index)); 737 ui::ListSelectionModel new_model; 738 new_model.Copy(selection_model_); 739 new_model.SetSelectionFromAnchorTo(index); 740 SetSelection(new_model, NOTIFY_DEFAULT); 741 } 742 743 void TabStripModel::ToggleSelectionAt(int index) { 744 DCHECK(ContainsIndex(index)); 745 ui::ListSelectionModel new_model; 746 new_model.Copy(selection_model()); 747 if (selection_model_.IsSelected(index)) { 748 if (selection_model_.size() == 1) { 749 // One tab must be selected and this tab is currently selected so we can't 750 // unselect it. 751 return; 752 } 753 new_model.RemoveIndexFromSelection(index); 754 new_model.set_anchor(index); 755 if (new_model.active() == index || 756 new_model.active() == ui::ListSelectionModel::kUnselectedIndex) 757 new_model.set_active(new_model.selected_indices()[0]); 758 } else { 759 new_model.AddIndexToSelection(index); 760 new_model.set_anchor(index); 761 new_model.set_active(index); 762 } 763 SetSelection(new_model, NOTIFY_DEFAULT); 764 } 765 766 void TabStripModel::AddSelectionFromAnchorTo(int index) { 767 ui::ListSelectionModel new_model; 768 new_model.Copy(selection_model_); 769 new_model.AddSelectionFromAnchorTo(index); 770 SetSelection(new_model, NOTIFY_DEFAULT); 771 } 772 773 bool TabStripModel::IsTabSelected(int index) const { 774 DCHECK(ContainsIndex(index)); 775 return selection_model_.IsSelected(index); 776 } 777 778 void TabStripModel::SetSelectionFromModel( 779 const ui::ListSelectionModel& source) { 780 DCHECK_NE(ui::ListSelectionModel::kUnselectedIndex, source.active()); 781 SetSelection(source, NOTIFY_DEFAULT); 782 } 783 784 void TabStripModel::AddWebContents(WebContents* contents, 785 int index, 786 content::PageTransition transition, 787 int add_types) { 788 // If the newly-opened tab is part of the same task as the parent tab, we want 789 // to inherit the parent's "group" attribute, so that if this tab is then 790 // closed we'll jump back to the parent tab. 791 bool inherit_group = (add_types & ADD_INHERIT_GROUP) == ADD_INHERIT_GROUP; 792 793 if (transition == content::PAGE_TRANSITION_LINK && 794 (add_types & ADD_FORCE_INDEX) == 0) { 795 // We assume tabs opened via link clicks are part of the same task as their 796 // parent. Note that when |force_index| is true (e.g. when the user 797 // drag-and-drops a link to the tab strip), callers aren't really handling 798 // link clicks, they just want to score the navigation like a link click in 799 // the history backend, so we don't inherit the group in this case. 800 index = order_controller_->DetermineInsertionIndex(transition, 801 add_types & ADD_ACTIVE); 802 inherit_group = true; 803 } else { 804 // For all other types, respect what was passed to us, normalizing -1s and 805 // values that are too large. 806 if (index < 0 || index > count()) 807 index = count(); 808 } 809 810 if (transition == content::PAGE_TRANSITION_TYPED && index == count()) { 811 // Also, any tab opened at the end of the TabStrip with a "TYPED" 812 // transition inherit group as well. This covers the cases where the user 813 // creates a New Tab (e.g. Ctrl+T, or clicks the New Tab button), or types 814 // in the address bar and presses Alt+Enter. This allows for opening a new 815 // Tab to quickly look up something. When this Tab is closed, the old one 816 // is re-selected, not the next-adjacent. 817 inherit_group = true; 818 } 819 InsertWebContentsAt(index, contents, 820 add_types | (inherit_group ? ADD_INHERIT_GROUP : 0)); 821 // Reset the index, just in case insert ended up moving it on us. 822 index = GetIndexOfWebContents(contents); 823 824 if (inherit_group && transition == content::PAGE_TRANSITION_TYPED) 825 contents_data_[index]->set_reset_group_on_select(true); 826 827 // TODO(sky): figure out why this is here and not in InsertWebContentsAt. When 828 // here we seem to get failures in startup perf tests. 829 // Ensure that the new WebContentsView begins at the same size as the 830 // previous WebContentsView if it existed. Otherwise, the initial WebKit 831 // layout will be performed based on a width of 0 pixels, causing a 832 // very long, narrow, inaccurate layout. Because some scripts on pages (as 833 // well as WebKit's anchor link location calculation) are run on the 834 // initial layout and not recalculated later, we need to ensure the first 835 // layout is performed with sane view dimensions even when we're opening a 836 // new background tab. 837 if (WebContents* old_contents = GetActiveWebContents()) { 838 if ((add_types & ADD_ACTIVE) == 0) { 839 apps::ResizeWebContents(contents, 840 old_contents->GetContainerBounds().size()); 841 } 842 } 843 } 844 845 void TabStripModel::CloseSelectedTabs() { 846 InternalCloseTabs(selection_model_.selected_indices(), 847 CLOSE_CREATE_HISTORICAL_TAB | CLOSE_USER_GESTURE); 848 } 849 850 void TabStripModel::SelectNextTab() { 851 SelectRelativeTab(true); 852 } 853 854 void TabStripModel::SelectPreviousTab() { 855 SelectRelativeTab(false); 856 } 857 858 void TabStripModel::SelectLastTab() { 859 ActivateTabAt(count() - 1, true); 860 } 861 862 void TabStripModel::MoveTabNext() { 863 // TODO: this likely needs to be updated for multi-selection. 864 int new_index = std::min(active_index() + 1, count() - 1); 865 MoveWebContentsAt(active_index(), new_index, true); 866 } 867 868 void TabStripModel::MoveTabPrevious() { 869 // TODO: this likely needs to be updated for multi-selection. 870 int new_index = std::max(active_index() - 1, 0); 871 MoveWebContentsAt(active_index(), new_index, true); 872 } 873 874 // Context menu functions. 875 bool TabStripModel::IsContextMenuCommandEnabled( 876 int context_index, ContextMenuCommand command_id) const { 877 DCHECK(command_id > CommandFirst && command_id < CommandLast); 878 switch (command_id) { 879 case CommandNewTab: 880 case CommandCloseTab: 881 return true; 882 883 case CommandReload: { 884 std::vector<int> indices = GetIndicesForCommand(context_index); 885 for (size_t i = 0; i < indices.size(); ++i) { 886 WebContents* tab = GetWebContentsAt(indices[i]); 887 if (tab) { 888 CoreTabHelperDelegate* core_delegate = 889 CoreTabHelper::FromWebContents(tab)->delegate(); 890 if (!core_delegate || core_delegate->CanReloadContents(tab)) 891 return true; 892 } 893 } 894 return false; 895 } 896 897 case CommandCloseOtherTabs: 898 case CommandCloseTabsToRight: 899 return !GetIndicesClosedByCommand(context_index, command_id).empty(); 900 901 case CommandDuplicate: { 902 std::vector<int> indices = GetIndicesForCommand(context_index); 903 for (size_t i = 0; i < indices.size(); ++i) { 904 if (delegate_->CanDuplicateContentsAt(indices[i])) 905 return true; 906 } 907 return false; 908 } 909 910 case CommandRestoreTab: 911 return delegate_->GetRestoreTabType() != 912 TabStripModelDelegate::RESTORE_NONE; 913 914 case CommandTogglePinned: { 915 std::vector<int> indices = GetIndicesForCommand(context_index); 916 for (size_t i = 0; i < indices.size(); ++i) { 917 if (!IsAppTab(indices[i])) 918 return true; 919 } 920 return false; 921 } 922 923 case CommandBookmarkAllTabs: 924 return browser_defaults::bookmarks_enabled && 925 delegate_->CanBookmarkAllTabs(); 926 927 case CommandSelectByDomain: 928 case CommandSelectByOpener: 929 return true; 930 931 default: 932 NOTREACHED(); 933 } 934 return false; 935 } 936 937 void TabStripModel::ExecuteContextMenuCommand( 938 int context_index, ContextMenuCommand command_id) { 939 DCHECK(command_id > CommandFirst && command_id < CommandLast); 940 switch (command_id) { 941 case CommandNewTab: 942 content::RecordAction(UserMetricsAction("TabContextMenu_NewTab")); 943 UMA_HISTOGRAM_ENUMERATION("Tab.NewTab", 944 TabStripModel::NEW_TAB_CONTEXT_MENU, 945 TabStripModel::NEW_TAB_ENUM_COUNT); 946 delegate()->AddTabAt(GURL(), context_index + 1, true); 947 break; 948 949 case CommandReload: { 950 content::RecordAction(UserMetricsAction("TabContextMenu_Reload")); 951 std::vector<int> indices = GetIndicesForCommand(context_index); 952 for (size_t i = 0; i < indices.size(); ++i) { 953 WebContents* tab = GetWebContentsAt(indices[i]); 954 if (tab) { 955 CoreTabHelperDelegate* core_delegate = 956 CoreTabHelper::FromWebContents(tab)->delegate(); 957 if (!core_delegate || core_delegate->CanReloadContents(tab)) 958 tab->GetController().Reload(true); 959 } 960 } 961 break; 962 } 963 964 case CommandDuplicate: { 965 content::RecordAction(UserMetricsAction("TabContextMenu_Duplicate")); 966 std::vector<int> indices = GetIndicesForCommand(context_index); 967 // Copy the WebContents off as the indices will change as tabs are 968 // duplicated. 969 std::vector<WebContents*> tabs; 970 for (size_t i = 0; i < indices.size(); ++i) 971 tabs.push_back(GetWebContentsAt(indices[i])); 972 for (size_t i = 0; i < tabs.size(); ++i) { 973 int index = GetIndexOfWebContents(tabs[i]); 974 if (index != -1 && delegate_->CanDuplicateContentsAt(index)) 975 delegate_->DuplicateContentsAt(index); 976 } 977 break; 978 } 979 980 case CommandCloseTab: { 981 content::RecordAction(UserMetricsAction("TabContextMenu_CloseTab")); 982 InternalCloseTabs(GetIndicesForCommand(context_index), 983 CLOSE_CREATE_HISTORICAL_TAB | CLOSE_USER_GESTURE); 984 break; 985 } 986 987 case CommandCloseOtherTabs: { 988 content::RecordAction( 989 UserMetricsAction("TabContextMenu_CloseOtherTabs")); 990 InternalCloseTabs(GetIndicesClosedByCommand(context_index, command_id), 991 CLOSE_CREATE_HISTORICAL_TAB); 992 break; 993 } 994 995 case CommandCloseTabsToRight: { 996 content::RecordAction( 997 UserMetricsAction("TabContextMenu_CloseTabsToRight")); 998 InternalCloseTabs(GetIndicesClosedByCommand(context_index, command_id), 999 CLOSE_CREATE_HISTORICAL_TAB); 1000 break; 1001 } 1002 1003 case CommandRestoreTab: { 1004 content::RecordAction(UserMetricsAction("TabContextMenu_RestoreTab")); 1005 delegate_->RestoreTab(); 1006 break; 1007 } 1008 1009 case CommandTogglePinned: { 1010 content::RecordAction( 1011 UserMetricsAction("TabContextMenu_TogglePinned")); 1012 std::vector<int> indices = GetIndicesForCommand(context_index); 1013 bool pin = WillContextMenuPin(context_index); 1014 if (pin) { 1015 for (size_t i = 0; i < indices.size(); ++i) { 1016 if (!IsAppTab(indices[i])) 1017 SetTabPinned(indices[i], true); 1018 } 1019 } else { 1020 // Unpin from the back so that the order is maintained (unpinning can 1021 // trigger moving a tab). 1022 for (size_t i = indices.size(); i > 0; --i) { 1023 if (!IsAppTab(indices[i - 1])) 1024 SetTabPinned(indices[i - 1], false); 1025 } 1026 } 1027 break; 1028 } 1029 1030 case CommandBookmarkAllTabs: { 1031 content::RecordAction( 1032 UserMetricsAction("TabContextMenu_BookmarkAllTabs")); 1033 1034 delegate_->BookmarkAllTabs(); 1035 break; 1036 } 1037 1038 case CommandSelectByDomain: 1039 case CommandSelectByOpener: { 1040 std::vector<int> indices; 1041 if (command_id == CommandSelectByDomain) 1042 GetIndicesWithSameDomain(context_index, &indices); 1043 else 1044 GetIndicesWithSameOpener(context_index, &indices); 1045 ui::ListSelectionModel selection_model; 1046 selection_model.SetSelectedIndex(context_index); 1047 for (size_t i = 0; i < indices.size(); ++i) 1048 selection_model.AddIndexToSelection(indices[i]); 1049 SetSelectionFromModel(selection_model); 1050 break; 1051 } 1052 1053 default: 1054 NOTREACHED(); 1055 } 1056 } 1057 1058 std::vector<int> TabStripModel::GetIndicesClosedByCommand( 1059 int index, 1060 ContextMenuCommand id) const { 1061 DCHECK(ContainsIndex(index)); 1062 DCHECK(id == CommandCloseTabsToRight || id == CommandCloseOtherTabs); 1063 bool is_selected = IsTabSelected(index); 1064 int start; 1065 if (id == CommandCloseTabsToRight) { 1066 if (is_selected) { 1067 start = selection_model_.selected_indices()[ 1068 selection_model_.selected_indices().size() - 1] + 1; 1069 } else { 1070 start = index + 1; 1071 } 1072 } else { 1073 start = 0; 1074 } 1075 // NOTE: callers expect the vector to be sorted in descending order. 1076 std::vector<int> indices; 1077 for (int i = count() - 1; i >= start; --i) { 1078 if (i != index && !IsMiniTab(i) && (!is_selected || !IsTabSelected(i))) 1079 indices.push_back(i); 1080 } 1081 return indices; 1082 } 1083 1084 bool TabStripModel::WillContextMenuPin(int index) { 1085 std::vector<int> indices = GetIndicesForCommand(index); 1086 // If all tabs are pinned, then we unpin, otherwise we pin. 1087 bool all_pinned = true; 1088 for (size_t i = 0; i < indices.size() && all_pinned; ++i) { 1089 if (!IsAppTab(index)) // We never change app tabs. 1090 all_pinned = IsTabPinned(indices[i]); 1091 } 1092 return !all_pinned; 1093 } 1094 1095 // static 1096 bool TabStripModel::ContextMenuCommandToBrowserCommand(int cmd_id, 1097 int* browser_cmd) { 1098 switch (cmd_id) { 1099 case CommandNewTab: 1100 *browser_cmd = IDC_NEW_TAB; 1101 break; 1102 case CommandReload: 1103 *browser_cmd = IDC_RELOAD; 1104 break; 1105 case CommandDuplicate: 1106 *browser_cmd = IDC_DUPLICATE_TAB; 1107 break; 1108 case CommandCloseTab: 1109 *browser_cmd = IDC_CLOSE_TAB; 1110 break; 1111 case CommandRestoreTab: 1112 *browser_cmd = IDC_RESTORE_TAB; 1113 break; 1114 case CommandBookmarkAllTabs: 1115 *browser_cmd = IDC_BOOKMARK_ALL_TABS; 1116 break; 1117 default: 1118 *browser_cmd = 0; 1119 return false; 1120 } 1121 1122 return true; 1123 } 1124 1125 /////////////////////////////////////////////////////////////////////////////// 1126 // TabStripModel, private: 1127 1128 std::vector<WebContents*> TabStripModel::GetWebContentsFromIndices( 1129 const std::vector<int>& indices) const { 1130 std::vector<WebContents*> contents; 1131 for (size_t i = 0; i < indices.size(); ++i) 1132 contents.push_back(GetWebContentsAtImpl(indices[i])); 1133 return contents; 1134 } 1135 1136 void TabStripModel::GetIndicesWithSameDomain(int index, 1137 std::vector<int>* indices) { 1138 std::string domain = GetWebContentsAt(index)->GetURL().host(); 1139 if (domain.empty()) 1140 return; 1141 for (int i = 0; i < count(); ++i) { 1142 if (i == index) 1143 continue; 1144 if (GetWebContentsAt(i)->GetURL().host() == domain) 1145 indices->push_back(i); 1146 } 1147 } 1148 1149 void TabStripModel::GetIndicesWithSameOpener(int index, 1150 std::vector<int>* indices) { 1151 WebContents* opener = contents_data_[index]->group(); 1152 if (!opener) { 1153 // If there is no group, find all tabs with the selected tab as the opener. 1154 opener = GetWebContentsAt(index); 1155 if (!opener) 1156 return; 1157 } 1158 for (int i = 0; i < count(); ++i) { 1159 if (i == index) 1160 continue; 1161 if (contents_data_[i]->group() == opener || 1162 GetWebContentsAtImpl(i) == opener) { 1163 indices->push_back(i); 1164 } 1165 } 1166 } 1167 1168 std::vector<int> TabStripModel::GetIndicesForCommand(int index) const { 1169 if (!IsTabSelected(index)) { 1170 std::vector<int> indices; 1171 indices.push_back(index); 1172 return indices; 1173 } 1174 return selection_model_.selected_indices(); 1175 } 1176 1177 bool TabStripModel::IsNewTabAtEndOfTabStrip(WebContents* contents) const { 1178 const GURL& url = contents->GetURL(); 1179 return url.SchemeIs(content::kChromeUIScheme) && 1180 url.host() == chrome::kChromeUINewTabHost && 1181 contents == GetWebContentsAtImpl(count() - 1) && 1182 contents->GetController().GetEntryCount() == 1; 1183 } 1184 1185 bool TabStripModel::InternalCloseTabs(const std::vector<int>& indices, 1186 uint32 close_types) { 1187 if (indices.empty()) 1188 return true; 1189 1190 CloseTracker close_tracker(GetWebContentsFromIndices(indices)); 1191 1192 base::WeakPtr<TabStripModel> ref(weak_factory_.GetWeakPtr()); 1193 const bool closing_all = indices.size() == contents_data_.size(); 1194 if (closing_all) 1195 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, WillCloseAllTabs()); 1196 1197 // We only try the fast shutdown path if the whole browser process is *not* 1198 // shutting down. Fast shutdown during browser termination is handled in 1199 // BrowserShutdown. 1200 if (browser_shutdown::GetShutdownType() == browser_shutdown::NOT_VALID) { 1201 // Construct a map of processes to the number of associated tabs that are 1202 // closing. 1203 std::map<content::RenderProcessHost*, size_t> processes; 1204 for (size_t i = 0; i < indices.size(); ++i) { 1205 WebContents* closing_contents = GetWebContentsAtImpl(indices[i]); 1206 if (delegate_->ShouldRunUnloadListenerBeforeClosing(closing_contents)) 1207 continue; 1208 content::RenderProcessHost* process = 1209 closing_contents->GetRenderProcessHost(); 1210 ++processes[process]; 1211 } 1212 1213 // Try to fast shutdown the tabs that can close. 1214 for (std::map<content::RenderProcessHost*, size_t>::iterator iter = 1215 processes.begin(); iter != processes.end(); ++iter) { 1216 iter->first->FastShutdownForPageCount(iter->second); 1217 } 1218 } 1219 1220 // We now return to our regularly scheduled shutdown procedure. 1221 bool retval = true; 1222 while (close_tracker.HasNext()) { 1223 WebContents* closing_contents = close_tracker.Next(); 1224 int index = GetIndexOfWebContents(closing_contents); 1225 // Make sure we still contain the tab. 1226 if (index == kNoTab) 1227 continue; 1228 1229 CoreTabHelper* core_tab_helper = 1230 CoreTabHelper::FromWebContents(closing_contents); 1231 core_tab_helper->OnCloseStarted(); 1232 1233 // Update the explicitly closed state. If the unload handlers cancel the 1234 // close the state is reset in Browser. We don't update the explicitly 1235 // closed state if already marked as explicitly closed as unload handlers 1236 // call back to this if the close is allowed. 1237 if (!closing_contents->GetClosedByUserGesture()) { 1238 closing_contents->SetClosedByUserGesture( 1239 close_types & CLOSE_USER_GESTURE); 1240 } 1241 1242 if (delegate_->RunUnloadListenerBeforeClosing(closing_contents)) { 1243 retval = false; 1244 continue; 1245 } 1246 1247 InternalCloseTab(closing_contents, index, 1248 (close_types & CLOSE_CREATE_HISTORICAL_TAB) != 0); 1249 } 1250 1251 if (ref && closing_all && !retval) { 1252 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 1253 CloseAllTabsCanceled()); 1254 } 1255 1256 return retval; 1257 } 1258 1259 void TabStripModel::InternalCloseTab(WebContents* contents, 1260 int index, 1261 bool create_historical_tabs) { 1262 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 1263 TabClosingAt(this, contents, index)); 1264 1265 // Ask the delegate to save an entry for this tab in the historical tab 1266 // database if applicable. 1267 if (create_historical_tabs) 1268 delegate_->CreateHistoricalTab(contents); 1269 1270 // Deleting the WebContents will call back to us via 1271 // WebContentsData::WebContentsDestroyed and detach it. 1272 delete contents; 1273 } 1274 1275 WebContents* TabStripModel::GetWebContentsAtImpl(int index) const { 1276 CHECK(ContainsIndex(index)) << 1277 "Failed to find: " << index << " in: " << count() << " entries."; 1278 return contents_data_[index]->web_contents(); 1279 } 1280 1281 void TabStripModel::NotifyIfTabDeactivated(WebContents* contents) { 1282 if (contents) { 1283 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 1284 TabDeactivated(contents)); 1285 } 1286 } 1287 1288 void TabStripModel::NotifyIfActiveTabChanged(WebContents* old_contents, 1289 NotifyTypes notify_types) { 1290 WebContents* new_contents = GetWebContentsAtImpl(active_index()); 1291 if (old_contents != new_contents) { 1292 int reason = notify_types == NOTIFY_USER_GESTURE 1293 ? TabStripModelObserver::CHANGE_REASON_USER_GESTURE 1294 : TabStripModelObserver::CHANGE_REASON_NONE; 1295 CHECK(!in_notify_); 1296 in_notify_ = true; 1297 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 1298 ActiveTabChanged(old_contents, 1299 new_contents, 1300 active_index(), 1301 reason)); 1302 in_notify_ = false; 1303 // Activating a discarded tab reloads it, so it is no longer discarded. 1304 contents_data_[active_index()]->set_discarded(false); 1305 } 1306 } 1307 1308 void TabStripModel::NotifyIfActiveOrSelectionChanged( 1309 WebContents* old_contents, 1310 NotifyTypes notify_types, 1311 const ui::ListSelectionModel& old_model) { 1312 NotifyIfActiveTabChanged(old_contents, notify_types); 1313 1314 if (!selection_model().Equals(old_model)) { 1315 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 1316 TabSelectionChanged(this, old_model)); 1317 } 1318 } 1319 1320 void TabStripModel::SetSelection( 1321 const ui::ListSelectionModel& new_model, 1322 NotifyTypes notify_types) { 1323 WebContents* old_contents = GetActiveWebContents(); 1324 ui::ListSelectionModel old_model; 1325 old_model.Copy(selection_model_); 1326 if (new_model.active() != selection_model_.active()) 1327 NotifyIfTabDeactivated(old_contents); 1328 selection_model_.Copy(new_model); 1329 NotifyIfActiveOrSelectionChanged(old_contents, notify_types, old_model); 1330 } 1331 1332 void TabStripModel::SelectRelativeTab(bool next) { 1333 // This may happen during automated testing or if a user somehow buffers 1334 // many key accelerators. 1335 if (contents_data_.empty()) 1336 return; 1337 1338 int index = active_index(); 1339 int delta = next ? 1 : -1; 1340 index = (index + count() + delta) % count(); 1341 ActivateTabAt(index, true); 1342 } 1343 1344 void TabStripModel::MoveWebContentsAtImpl(int index, 1345 int to_position, 1346 bool select_after_move) { 1347 WebContentsData* moved_data = contents_data_[index]; 1348 contents_data_.erase(contents_data_.begin() + index); 1349 contents_data_.insert(contents_data_.begin() + to_position, moved_data); 1350 1351 selection_model_.Move(index, to_position); 1352 if (!selection_model_.IsSelected(select_after_move) && select_after_move) { 1353 // TODO(sky): why doesn't this code notify observers? 1354 selection_model_.SetSelectedIndex(to_position); 1355 } 1356 1357 ForgetOpenersAndGroupsReferencing(moved_data->web_contents()); 1358 1359 FOR_EACH_OBSERVER(TabStripModelObserver, observers_, 1360 TabMoved(moved_data->web_contents(), index, to_position)); 1361 } 1362 1363 void TabStripModel::MoveSelectedTabsToImpl(int index, 1364 size_t start, 1365 size_t length) { 1366 DCHECK(start < selection_model_.selected_indices().size() && 1367 start + length <= selection_model_.selected_indices().size()); 1368 size_t end = start + length; 1369 int count_before_index = 0; 1370 for (size_t i = start; i < end && 1371 selection_model_.selected_indices()[i] < index + count_before_index; 1372 ++i) { 1373 count_before_index++; 1374 } 1375 1376 // First move those before index. Any tabs before index end up moving in the 1377 // selection model so we use start each time through. 1378 int target_index = index + count_before_index; 1379 size_t tab_index = start; 1380 while (tab_index < end && 1381 selection_model_.selected_indices()[start] < index) { 1382 MoveWebContentsAt(selection_model_.selected_indices()[start], 1383 target_index - 1, false); 1384 tab_index++; 1385 } 1386 1387 // Then move those after the index. These don't result in reordering the 1388 // selection. 1389 while (tab_index < end) { 1390 if (selection_model_.selected_indices()[tab_index] != target_index) { 1391 MoveWebContentsAt(selection_model_.selected_indices()[tab_index], 1392 target_index, false); 1393 } 1394 tab_index++; 1395 target_index++; 1396 } 1397 } 1398 1399 // static 1400 bool TabStripModel::OpenerMatches(const WebContentsData* data, 1401 const WebContents* opener, 1402 bool use_group) { 1403 return data->opener() == opener || (use_group && data->group() == opener); 1404 } 1405 1406 void TabStripModel::ForgetOpenersAndGroupsReferencing( 1407 const WebContents* tab) { 1408 for (WebContentsDataVector::const_iterator i = contents_data_.begin(); 1409 i != contents_data_.end(); ++i) { 1410 if ((*i)->group() == tab) 1411 (*i)->set_group(NULL); 1412 if ((*i)->opener() == tab) 1413 (*i)->set_opener(NULL); 1414 } 1415 } 1416