Home | History | Annotate | Download | only in ash 
      1 // Copyright (c) 2013 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/views/ash/tab_scrubber.h"
      6 
      7 #include "ash/shell.h"
      8 #include "ash/wm/window_util.h"
      9 #include "base/metrics/histogram.h"
     10 #include "chrome/browser/chrome_notification_types.h"
     11 #include "chrome/browser/ui/browser.h"
     12 #include "chrome/browser/ui/browser_finder.h"
     13 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     14 #include "chrome/browser/ui/views/frame/browser_view.h"
     15 #include "chrome/browser/ui/views/tabs/tab.h"
     16 #include "chrome/browser/ui/views/tabs/tab_strip.h"
     17 #include "chrome/common/pref_names.h"
     18 #include "content/public/browser/notification_service.h"
     19 #include "content/public/browser/notification_source.h"
     20 #include "ui/aura/window.h"
     21 #include "ui/base/events/event.h"
     22 #include "ui/base/events/event_utils.h"
     23 #include "ui/base/gestures/gesture_configuration.h"
     24 #include "ui/views/controls/glow_hover_controller.h"
     25 
     26 namespace {
     27 const int64 kActivationDelayMS = 200;
     28 }
     29 
     30 // static
     31 TabScrubber* TabScrubber::GetInstance() {
     32   static TabScrubber* instance = NULL;
     33   if (!instance)
     34     instance = new TabScrubber();
     35   return instance;
     36 }
     37 
     38 // static
     39 gfx::Point TabScrubber::GetStartPoint(
     40     TabStrip* tab_strip,
     41     int index,
     42     TabScrubber::Direction direction) {
     43   int initial_tab_offset = Tab::GetMiniWidth() / 2;
     44   gfx::Rect tab_bounds = tab_strip->tab_at(index)->bounds();
     45   float x = direction == LEFT ?
     46       tab_bounds.x() + initial_tab_offset :
     47           tab_bounds.right() - initial_tab_offset;
     48   return gfx::Point(x, tab_bounds.CenterPoint().y());
     49 }
     50 
     51 bool TabScrubber::IsActivationPending() {
     52   return activate_timer_.IsRunning();
     53 }
     54 
     55 TabScrubber::TabScrubber()
     56     : scrubbing_(false),
     57       browser_(NULL),
     58       swipe_x_(-1),
     59       swipe_y_(-1),
     60       swipe_direction_(LEFT),
     61       highlighted_tab_(-1),
     62       activate_timer_(true, false),
     63       activation_delay_(kActivationDelayMS),
     64       use_default_activation_delay_(true),
     65       weak_ptr_factory_(this) {
     66   ash::Shell::GetInstance()->AddPreTargetHandler(this);
     67   registrar_.Add(
     68       this,
     69       chrome::NOTIFICATION_BROWSER_CLOSED,
     70       content::NotificationService::AllSources());
     71 }
     72 
     73 TabScrubber::~TabScrubber() {
     74   // Note: The weak_ptr_factory_ should invalidate  its weak pointers before
     75   // any other members are destroyed.
     76   weak_ptr_factory_.InvalidateWeakPtrs();
     77 }
     78 
     79 void TabScrubber::OnScrollEvent(ui::ScrollEvent* event) {
     80   if (event->type() == ui::ET_SCROLL_FLING_CANCEL ||
     81       event->type() == ui::ET_SCROLL_FLING_START) {
     82     FinishScrub(true);
     83     immersive_reveal_lock_.reset();
     84     return;
     85   }
     86 
     87   if (event->finger_count() != 3)
     88     return;
     89 
     90   Browser* browser = GetActiveBrowser();
     91   if (!browser || (scrubbing_ && browser_ && browser != browser_) ||
     92       (highlighted_tab_ != -1 &&
     93           highlighted_tab_ >= browser->tab_strip_model()->count())) {
     94     FinishScrub(false);
     95     return;
     96   }
     97 
     98   BrowserView* browser_view =
     99       BrowserView::GetBrowserViewForNativeWindow(
    100           browser->window()->GetNativeWindow());
    101   TabStrip* tab_strip = browser_view->tabstrip();
    102 
    103   if (tab_strip->IsAnimating()) {
    104     FinishScrub(false);
    105     return;
    106   }
    107 
    108   // We are handling the event.
    109   event->StopPropagation();
    110 
    111   float x_offset = event->x_offset();
    112   if (!ui::IsNaturalScrollEnabled())
    113     x_offset = -x_offset;
    114   int last_tab_index = highlighted_tab_ == -1 ?
    115       browser->tab_strip_model()->active_index() : highlighted_tab_;
    116   if (!scrubbing_) {
    117     swipe_direction_ = (x_offset < 0) ? LEFT : RIGHT;
    118     const gfx::Point start_point =
    119         GetStartPoint(tab_strip,
    120                       browser->tab_strip_model()->active_index(),
    121                       swipe_direction_);
    122     browser_ = browser;
    123     scrubbing_ = true;
    124 
    125     swipe_x_ = start_point.x();
    126     swipe_y_ = start_point.y();
    127     ImmersiveModeController* immersive_controller =
    128         browser_view->immersive_mode_controller();
    129     if (immersive_controller->IsEnabled()) {
    130       immersive_reveal_lock_.reset(immersive_controller->GetRevealedLock(
    131           ImmersiveModeController::ANIMATE_REVEAL_YES));
    132     }
    133     tab_strip->AddObserver(this);
    134   } else if (highlighted_tab_ == -1) {
    135     Direction direction = (x_offset < 0) ? LEFT : RIGHT;
    136     if (direction != swipe_direction_) {
    137       const gfx::Point start_point =
    138           GetStartPoint(tab_strip,
    139                         browser->tab_strip_model()->active_index(),
    140                         direction);
    141       swipe_x_ = start_point.x();
    142       swipe_y_ = start_point.y();
    143       swipe_direction_ = direction;
    144     }
    145   }
    146 
    147   swipe_x_ += x_offset;
    148   Tab* first_tab = tab_strip->tab_at(0);
    149   int first_tab_center = first_tab->bounds().CenterPoint().x();
    150   Tab* last_tab = tab_strip->tab_at(tab_strip->tab_count() - 1);
    151   int last_tab_tab_center = last_tab->bounds().CenterPoint().x();
    152   if (swipe_x_ < first_tab_center)
    153     swipe_x_ = first_tab_center;
    154   if (swipe_x_ > last_tab_tab_center)
    155     swipe_x_ = last_tab_tab_center;
    156 
    157   Tab* initial_tab = tab_strip->tab_at(last_tab_index);
    158   gfx::Point tab_point(swipe_x_, swipe_y_);
    159   views::View::ConvertPointToTarget(tab_strip, initial_tab, &tab_point);
    160   Tab* new_tab = tab_strip->GetTabAt(initial_tab, tab_point);
    161   if (!new_tab)
    162     return;
    163 
    164   int new_index = tab_strip->GetModelIndexOfTab(new_tab);
    165   if (highlighted_tab_ == -1 &&
    166       new_index == browser->tab_strip_model()->active_index())
    167     return;
    168 
    169   if (new_index != highlighted_tab_) {
    170     if (activate_timer_.IsRunning()) {
    171       activate_timer_.Reset();
    172     } else {
    173       int delay = use_default_activation_delay_ ?
    174           ui::GestureConfiguration::tab_scrub_activation_delay_in_ms() :
    175           activation_delay_;
    176       if (delay >= 0) {
    177         activate_timer_.Start(FROM_HERE,
    178                               base::TimeDelta::FromMilliseconds(delay),
    179                               base::Bind(&TabScrubber::FinishScrub,
    180                                          weak_ptr_factory_.GetWeakPtr(),
    181                                          true));
    182       }
    183     }
    184     if (highlighted_tab_ != -1) {
    185       Tab* tab = tab_strip->tab_at(highlighted_tab_);
    186       tab->hover_controller()->HideImmediately();
    187     }
    188     if (new_index == browser->tab_strip_model()->active_index()) {
    189       highlighted_tab_ = -1;
    190     } else {
    191       highlighted_tab_ = new_index;
    192       new_tab->hover_controller()->Show(views::GlowHoverController::PRONOUNCED);
    193     }
    194   }
    195   if (highlighted_tab_ != -1) {
    196     gfx::Point hover_point(swipe_x_, swipe_y_);
    197     views::View::ConvertPointToTarget(tab_strip, new_tab, &hover_point);
    198     new_tab->hover_controller()->SetLocation(hover_point);
    199   }
    200 }
    201 
    202 void TabScrubber::Observe(int type,
    203                           const content::NotificationSource& source,
    204                           const content::NotificationDetails& details) {
    205   if (content::Source<Browser>(source).ptr() == browser_) {
    206     activate_timer_.Stop();
    207     swipe_x_ = -1;
    208     swipe_y_ = -1;
    209     scrubbing_ = false;
    210     highlighted_tab_ = -1;
    211     browser_ = NULL;
    212   }
    213 }
    214 
    215 void TabScrubber::TabStripAddedTabAt(TabStrip* tab_strip, int index) {
    216   if (highlighted_tab_ == -1)
    217     return;
    218 
    219   if (index < highlighted_tab_)
    220     ++highlighted_tab_;
    221 }
    222 
    223 void TabScrubber::TabStripMovedTab(TabStrip* tab_strip,
    224                                    int from_index,
    225                                    int to_index) {
    226   if (highlighted_tab_ == -1)
    227     return;
    228 
    229   if (from_index == highlighted_tab_)
    230     highlighted_tab_ = to_index;
    231   else if (from_index < highlighted_tab_&& highlighted_tab_<= to_index)
    232     --highlighted_tab_;
    233   else if (from_index > highlighted_tab_ && highlighted_tab_ >= to_index)
    234     ++highlighted_tab_;
    235 }
    236 
    237 void TabScrubber::TabStripRemovedTabAt(TabStrip* tab_strip, int index) {
    238   if (highlighted_tab_ == -1)
    239     return;
    240   if (index == highlighted_tab_) {
    241     FinishScrub(false);
    242     return;
    243   }
    244   if (index < highlighted_tab_)
    245     --highlighted_tab_;
    246 }
    247 
    248 void TabScrubber::TabStripDeleted(TabStrip* tab_strip) {
    249   if (highlighted_tab_ == -1)
    250     return;
    251 }
    252 
    253 Browser* TabScrubber::GetActiveBrowser() {
    254   aura::Window* active_window = ash::wm::GetActiveWindow();
    255   if (!active_window)
    256     return NULL;
    257 
    258   Browser* browser = chrome::FindBrowserWithWindow(active_window);
    259   if (!browser || browser->type() != Browser::TYPE_TABBED)
    260     return NULL;
    261 
    262   return browser;
    263 }
    264 
    265 void TabScrubber::FinishScrub(bool activate) {
    266   activate_timer_.Stop();
    267 
    268   if (browser_ && browser_->window()) {
    269     BrowserView* browser_view =
    270         BrowserView::GetBrowserViewForNativeWindow(
    271             browser_->window()->GetNativeWindow());
    272     TabStrip* tab_strip = browser_view->tabstrip();
    273     if (activate && highlighted_tab_ != -1) {
    274       Tab* tab = tab_strip->tab_at(highlighted_tab_);
    275       tab->hover_controller()->HideImmediately();
    276       int distance =
    277           std::abs(
    278               highlighted_tab_ - browser_->tab_strip_model()->active_index());
    279       UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.ScrubDistance", distance, 0, 20, 20);
    280       browser_->tab_strip_model()->ActivateTabAt(highlighted_tab_, true);
    281     }
    282     tab_strip->RemoveObserver(this);
    283   }
    284   swipe_x_ = -1;
    285   swipe_y_ = -1;
    286   scrubbing_ = false;
    287   highlighted_tab_ = -1;
    288 }
    289