Home | History | Annotate | Download | only in ui 
      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/active_tab_tracker.h"
      6 
      7 #include "chrome/browser/history/history_service.h"
      8 #include "chrome/browser/history/history_service_factory.h"
      9 #include "chrome/browser/profiles/profile.h"
     10 #include "chrome/browser/ui/browser.h"
     11 #include "chrome/browser/ui/browser_list.h"
     12 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     13 #include "content/public/browser/navigation_entry.h"
     14 #include "content/public/browser/notification_source.h"
     15 #include "content/public/browser/notification_types.h"
     16 #include "content/public/browser/web_contents.h"
     17 
     18 namespace {
     19 
     20 // Amount of time a page has to be active before we commit it.
     21 const int kTimeBeforeCommitMS = 1000;
     22 
     23 // Number of seconds input should be received before considered idle.
     24 const int kIdleTimeSeconds = 30;
     25 
     26 }  // namespace
     27 
     28 #if !defined(OS_WIN) && !defined(USE_AURA)
     29 // static
     30 NativeFocusTracker* NativeFocusTracker::Create(NativeFocusTrackerHost* host) {
     31   return NULL;
     32 }
     33 #endif
     34 
     35 ActiveTabTracker::ActiveTabTracker()
     36     : browser_(NULL),
     37       web_contents_(NULL),
     38       idle_state_(IDLE_STATE_UNKNOWN),
     39       timer_(false, false),
     40       weak_ptr_factory_(this) {
     41   native_focus_tracker_.reset(NativeFocusTracker::Create(this));
     42   Browser* browser =
     43       BrowserList::GetInstance(chrome::GetActiveDesktop())->GetLastActive();
     44   SetBrowser(browser);
     45   BrowserList::AddObserver(this);
     46 }
     47 
     48 ActiveTabTracker::~ActiveTabTracker() {
     49   native_focus_tracker_.reset();
     50   SetBrowser(NULL);
     51   BrowserList::RemoveObserver(this);
     52 }
     53 
     54 void ActiveTabTracker::ActiveTabChanged(content::WebContents* old_contents,
     55                                         content::WebContents* new_contents,
     56                                         int index,
     57                                         int reason) {
     58   SetWebContents(new_contents);
     59 }
     60 
     61 void ActiveTabTracker::TabReplacedAt(TabStripModel* tab_strip_model,
     62                                      content::WebContents* old_contents,
     63                                      content::WebContents* new_contents,
     64                                      int index) {
     65   if (index == tab_strip_model->selection_model().active())
     66     SetWebContents(new_contents);
     67 }
     68 
     69 void ActiveTabTracker::TabStripEmpty() {
     70   SetBrowser(NULL);
     71 }
     72 
     73 void ActiveTabTracker::OnBrowserRemoved(Browser* browser) {
     74   if (browser == browser_)
     75     SetBrowser(NULL);
     76 }
     77 
     78 void ActiveTabTracker::Observe(int type,
     79                                const content::NotificationSource& source,
     80                                const content::NotificationDetails& details) {
     81   const GURL url = GetURLFromWebContents();
     82   if (url == url_)
     83     return;
     84 
     85   CommitActiveTime();
     86   url_ = url;
     87 }
     88 
     89 void ActiveTabTracker::SetBrowser(Browser* browser) {
     90   if (browser_ == browser)
     91     return;
     92 
     93   CommitActiveTime();
     94   if (browser_)
     95     browser_->tab_strip_model()->RemoveObserver(this);
     96   // Don't track anything for otr profiles.
     97   if (browser && browser->profile()->IsOffTheRecord())
     98     browser = NULL;
     99   browser_ = browser;
    100   content::WebContents* web_contents = NULL;
    101   if (browser_) {
    102     TabStripModel* tab_strip = browser_->tab_strip_model();
    103     tab_strip->AddObserver(this);
    104     web_contents = tab_strip->GetActiveWebContents();
    105   } else {
    106     idle_state_ = IDLE_STATE_UNKNOWN;
    107     timer_.Stop();
    108     weak_ptr_factory_.InvalidateWeakPtrs();
    109   }
    110   SetWebContents(web_contents);
    111 }
    112 
    113 void ActiveTabTracker::SetWebContents(content::WebContents* web_contents) {
    114   if (web_contents_ == web_contents)
    115     return;
    116 
    117   CommitActiveTime();
    118 
    119   active_time_ = base::TimeTicks::Now();
    120   web_contents_ = web_contents;
    121   url_ = GetURLFromWebContents();
    122   registrar_.RemoveAll();
    123   // TODO(sky): this isn't quite right. We should really not include transient
    124   // entries here. For that we need to make Browser::NavigationStateChanged()
    125   // call through to this class.
    126   if (web_contents_) {
    127     registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
    128                    content::Source<content::NavigationController>(
    129                        &web_contents_->GetController()));
    130     QueryIdleState();
    131   }
    132 }
    133 
    134 void ActiveTabTracker::SetIdleState(IdleState idle_state) {
    135   if (idle_state_ != idle_state) {
    136     if (idle_state_ == IDLE_STATE_ACTIVE)
    137       CommitActiveTime();
    138     else if (idle_state == IDLE_STATE_ACTIVE)
    139       active_time_ = base::TimeTicks::Now();
    140     idle_state_ = idle_state;
    141   }
    142   if (browser_) {
    143     timer_.Start(FROM_HERE,
    144                  base::TimeDelta::FromSeconds(kIdleTimeSeconds),
    145                  base::Bind(&ActiveTabTracker::QueryIdleState,
    146                             base::Unretained(this)));
    147   }
    148 }
    149 
    150 void ActiveTabTracker::QueryIdleState() {
    151   if (weak_ptr_factory_.HasWeakPtrs())
    152     return;
    153 
    154   CalculateIdleState(kIdleTimeSeconds,
    155                      base::Bind(&ActiveTabTracker::SetIdleState,
    156                                 weak_ptr_factory_.GetWeakPtr()));
    157 }
    158 
    159 GURL ActiveTabTracker::GetURLFromWebContents() const {
    160   if (!web_contents_)
    161     return GURL();
    162 
    163   // TODO: handle subframe transitions better. Maybe go back to first entry
    164   // that isn't a main frame?
    165   content::NavigationEntry* entry =
    166       web_contents_->GetController().GetLastCommittedEntry();
    167   if (!entry || !PageTransitionIsMainFrame(entry->GetTransitionType()))
    168     return GURL();
    169   return !entry->GetUserTypedURL().is_empty() ?
    170       entry->GetUserTypedURL() : entry->GetURL();
    171 }
    172 
    173 void ActiveTabTracker::CommitActiveTime() {
    174   const base::TimeDelta active_delta = base::TimeTicks::Now() - active_time_;
    175   active_time_ = base::TimeTicks::Now();
    176 
    177   if (!web_contents_ || url_.is_empty() || idle_state_ != IDLE_STATE_ACTIVE ||
    178       active_delta.InMilliseconds() < kTimeBeforeCommitMS)
    179     return;
    180 
    181   Profile* profile = Profile::FromBrowserContext(
    182       web_contents_->GetBrowserContext());
    183   HistoryService* history = HistoryServiceFactory::GetForProfile(
    184       profile, Profile::EXPLICIT_ACCESS);
    185   if (history)
    186     history->IncreaseSegmentDuration(url_, base::Time::Now(), active_delta);
    187 }
    188