1// Copyright (c) 2010 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#ifndef CHROME_BROWSER_SESSIONS_SESSION_TYPES_H_
6#define CHROME_BROWSER_SESSIONS_SESSION_TYPES_H_
7#pragma once
8
9#include <string>
10#include <vector>
11
12#include "base/stl_util-inl.h"
13#include "base/string16.h"
14#include "base/time.h"
15#include "chrome/browser/sessions/session_id.h"
16#include "content/common/page_transition_types.h"
17#include "googleurl/src/gurl.h"
18#include "ui/gfx/rect.h"
19
20class NavigationEntry;
21class Profile;
22
23// TabNavigation  -------------------------------------------------------------
24
25// TabNavigation corresponds to the parts of NavigationEntry needed to restore
26// the NavigationEntry during session restore and tab restore.
27//
28// TabNavigation is cheap and supports copy semantics.
29class TabNavigation {
30 public:
31  enum TypeMask {
32    HAS_POST_DATA = 1
33  };
34
35  TabNavigation();
36  TabNavigation(int index,
37                const GURL& virtual_url,
38                const GURL& referrer,
39                const string16& title,
40                const std::string& state,
41                PageTransition::Type transition);
42  TabNavigation(const TabNavigation& tab);
43  ~TabNavigation();
44  TabNavigation& operator=(const TabNavigation& tab);
45
46  // Converts this TabNavigation into a NavigationEntry with a page id of
47  // |page_id|. The caller owns the returned NavigationEntry.
48  NavigationEntry* ToNavigationEntry(int page_id, Profile* profile) const;
49
50  // Resets this TabNavigation from |entry|.
51  void SetFromNavigationEntry(const NavigationEntry& entry);
52
53  // Virtual URL of the page. See NavigationEntry::virtual_url() for details.
54  void set_virtual_url(const GURL& url) { virtual_url_ = url; }
55  const GURL& virtual_url() const { return virtual_url_; }
56
57  // The referrer.
58  const GURL& referrer() const { return referrer_; }
59
60  // The title of the page.
61  const string16& title() const { return title_; }
62
63  // State bits.
64  const std::string& state() const { return state_; }
65
66  // Transition type.
67  void set_transition(PageTransition::Type transition) {
68    transition_ = transition;
69  }
70  PageTransition::Type transition() const { return transition_; }
71
72  // A mask used for arbitrary boolean values needed to represent a
73  // NavigationEntry. Currently only contains HAS_POST_DATA or 0.
74  void set_type_mask(int type_mask) { type_mask_ = type_mask; }
75  int type_mask() const { return type_mask_; }
76
77  // The index in the NavigationController. If this is -1, it means this
78  // TabNavigation is bogus.
79  //
80  // This is used when determining the selected TabNavigation and only useful
81  // by BaseSessionService and SessionService.
82  void set_index(int index) { index_ = index; }
83  int index() const { return index_; }
84
85 private:
86  friend class BaseSessionService;
87
88  GURL virtual_url_;
89  GURL referrer_;
90  string16 title_;
91  std::string state_;
92  PageTransition::Type transition_;
93  int type_mask_;
94
95  int index_;
96};
97
98// SessionTab ----------------------------------------------------------------
99
100// SessionTab corresponds to a NavigationController.
101struct SessionTab {
102  SessionTab();
103  ~SessionTab();
104
105  // Unique id of the window.
106  SessionID window_id;
107
108  // Unique if of the tab.
109  SessionID tab_id;
110
111  // Visual index of the tab within its window. There may be gaps in these
112  // values.
113  //
114  // NOTE: this is really only useful for the SessionService during
115  // restore, others can likely ignore this and use the order of the
116  // tabs in SessionWindow.tabs.
117  int tab_visual_index;
118
119  // Identifies the index of the current navigation in navigations. For
120  // example, if this is 2 it means the current navigation is navigations[2].
121  //
122  // NOTE: when the service is creating SessionTabs, initially this
123  // corresponds to TabNavigation.index, not the index in navigations. When done
124  // creating though, this is set to the index in navigations.
125  //
126  // NOTE 2: this value can be larger than the size of |navigations|, due to
127  // only valid url's being stored (ie chrome://newtab is not stored). Bounds
128  // checking must be performed before indexing into |navigations|.
129  int current_navigation_index;
130
131  // True if the tab is pinned.
132  bool pinned;
133
134  // If non-empty, this tab is an app tab and this is the id of the extension.
135  std::string extension_app_id;
136
137  // Timestamp for when this tab was last modified.
138  base::Time timestamp;
139
140  std::vector<TabNavigation> navigations;
141
142 private:
143  DISALLOW_COPY_AND_ASSIGN(SessionTab);
144};
145
146// SessionWindow -------------------------------------------------------------
147
148// Describes a saved window.
149struct SessionWindow {
150  SessionWindow();
151  ~SessionWindow();
152
153  // Identifier of the window.
154  SessionID window_id;
155
156  // Bounds of the window.
157  gfx::Rect bounds;
158
159  // Index of the selected tab in tabs; -1 if no tab is selected. After restore
160  // this value is guaranteed to be a valid index into tabs.
161  //
162  // NOTE: when the service is creating SessionWindows, initially this
163  // corresponds to SessionTab.tab_visual_index, not the index in
164  // tabs. When done creating though, this is set to the index in
165  // tabs.
166  int selected_tab_index;
167
168  // Type of the browser. Currently we only store browsers of type
169  // TYPE_NORMAL and TYPE_POPUP.
170  // This would be Browser::Type, but that would cause a circular dependency.
171  int type;
172
173  // If true, the window is constrained.
174  //
175  // Currently SessionService prunes all constrained windows so that session
176  // restore does not attempt to restore them.
177  bool is_constrained;
178
179  // Timestamp for when this window was last modified.
180  base::Time timestamp;
181
182  // The tabs, ordered by visual order.
183  std::vector<SessionTab*> tabs;
184
185  // Is the window maximized?
186  bool is_maximized;
187
188 private:
189  DISALLOW_COPY_AND_ASSIGN(SessionWindow);
190};
191
192// Defines a foreign session for session sync.  A foreign session is a session
193// on a remote chrome instance.
194struct ForeignSession {
195  ForeignSession();
196  ~ForeignSession();
197
198  // Unique tag for each session.
199  std::string foreign_session_tag;
200  std::vector<SessionWindow*> windows;
201};
202
203#endif  // CHROME_BROWSER_SESSIONS_SESSION_TYPES_H_
204