1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// Copyright (c) 2010 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.
#ifndef CHROME_BROWSER_CHROMEOS_TAB_CLOSEABLE_STATE_WATCHER_H_
#define CHROME_BROWSER_CHROMEOS_TAB_CLOSEABLE_STATE_WATCHER_H_
#pragma once
#include <vector>
#include "chrome/browser/browser_list.h"
#include "chrome/browser/tab_closeable_state_watcher.h"
#include "chrome/browser/tabs/tab_strip_model.h"
#include "chrome/common/notification_registrar.h"
namespace chromeos {
// This class overrides ::TabCloseableStateWatcher to allow or disallow tabs or
// browsers to be closed based on increase or decrease in number of tabs or
// browsers. We only do this on Chromeos and only for non-tests.
// 1) A tab, and hence its containing browser, is not closeable if the tab is
// the last NewTabPage in the last normal non-incognito browser and user is not
// signing off.
// 2) Otherwise, if user closes a normal non-incognito browser or the last tab
// in it, the browser stays open, the existing tabs are closed, and a new
// NewTabPage is opened.
// 3) Or, if user closes a normal incognito browser or the last tab in it, the
// browser closes, a new non-incognito normal browser is opened with a
// NewTabPage (which, by rule 1, will not be closeable).
class TabCloseableStateWatcher : public ::TabCloseableStateWatcher,
public BrowserList::Observer,
public NotificationObserver {
public:
TabCloseableStateWatcher();
virtual ~TabCloseableStateWatcher();
// TabCloseableStateWatcher implementation:
virtual bool CanCloseTab(const Browser* browser) const;
virtual bool CanCloseBrowser(Browser* browser);
virtual void OnWindowCloseCanceled(Browser* browser);
private:
enum BrowserActionType {
NONE = 0, // Nothing to do.
OPEN_WINDOW = 1, // Opens a regular (i.e. non-incognito) normal browser.
OPEN_NTP = 2, // Opens a NewTabPage.
};
// BrowserList::Observer implementation:
virtual void OnBrowserAdded(const Browser* browser);
virtual void OnBrowserRemoving(const Browser* browser);
// NotificationObserver implementation:
virtual void Observe(NotificationType type, const NotificationSource& source,
const NotificationDetails& details);
// Called by private class TabStripWatcher for TabStripModelObserver
// notifications.
// |closing_last_tab| is true if the tab strip is closing the last tab.
virtual void OnTabStripChanged(const Browser* browser, bool closing_last_tab);
// Utility functions.
// Checks the closeable state of tab. If it has changed, updates it and
// notifies all normal browsers.
// |browser_to_check| is the browser whose closeable state the caller is
// interested in; can be NULL if caller is interested in all browsers, e.g.
// when a browser is being removed and there's no specific browser to check.
void CheckAndUpdateState(const Browser* browser_to_check);
// Sets the new closeable state and fires notification.
void SetCloseableState(bool closeable);
// Returns true if closing of |browser| is permitted.
// |action_type| is the action to take regardless if browser is closeable.
bool CanCloseBrowserImpl(const Browser* browser,
BrowserActionType* action_type) const;
// Data members.
// This is true if tab can be closed; it's updated in CheckAndUpdateState and
// when sign-off notification is received.
bool can_close_tab_;
// This is true when sign-off notification is received; it lets us know to
// allow closing of all tabs and browsers in this situation.
bool signing_off_;
NotificationRegistrar notification_registrar_;
// TabStripWatcher is a TabStripModelObserver that funnels all interesting
// methods to TabCloseableStateWatcher::OnTabStripChanged. TabStripWatcher is
// needed so we know which browser the TabStripModelObserver method relates
// to.
class TabStripWatcher : public TabStripModelObserver {
public:
TabStripWatcher(TabCloseableStateWatcher* main_watcher,
const Browser* browser);
virtual ~TabStripWatcher();
// TabStripModelObserver implementation:
virtual void TabInsertedAt(TabContents* contents, int index,
bool foreground);
virtual void TabClosingAt(TabContents* contents, int index);
virtual void TabDetachedAt(TabContents* contents, int index);
virtual void TabChangedAt(TabContents* contents, int index,
TabChangeType change_type);
const Browser* browser() const {
return browser_;
}
private:
TabCloseableStateWatcher* main_watcher_;
const Browser* browser_;
DISALLOW_COPY_AND_ASSIGN(TabStripWatcher);
};
friend class TabStripWatcher;
std::vector<TabStripWatcher*> tabstrip_watchers_;
DISALLOW_COPY_AND_ASSIGN(TabCloseableStateWatcher);
};
} // namespace chromeos
#endif // CHROME_BROWSER_CHROMEOS_TAB_CLOSEABLE_STATE_WATCHER_H_
|
