text: // Copyright (c) 2012 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_SESSIONS_SESSION_TYPES_H_
  #define CHROME_BROWSER_SESSIONS_SESSION_TYPES_H_
  
  #include <algorithm>
  #include <string>
  #include <vector>
  
  #include "base/memory/scoped_ptr.h"
  #include "base/strings/string16.h"
  #include "base/time/time.h"
  #include "components/sessions/serialized_navigation_entry.h"
  #include "components/sessions/session_id.h"
  #include "sync/protocol/session_specifics.pb.h"
  #include "ui/base/ui_base_types.h"
  #include "ui/gfx/rect.h"
  #include "url/gurl.h"
  
  namespace content {
  class BrowserContext;
  class NavigationEntry;
  }
  
  // SessionTab ----------------------------------------------------------------
  
  // SessionTab corresponds to a NavigationController.
  struct SessionTab {
    SessionTab();
    ~SessionTab();
  
    // Since the current_navigation_index can be larger than the index for number
    // of navigations in the current sessions (chrome://newtab is not stored), we
    // must perform bounds checking.
    // Returns a normalized bounds-checked navigation_index.
    int normalized_navigation_index() const {
      return std::max(0, std::min(current_navigation_index,
                                  static_cast<int>(navigations.size() - 1)));
    }
  
    // Set all the fields of this object from the given sync data and
    // timestamp.  Uses SerializedNavigationEntry::FromSyncData to fill
    // |navigations|.  Note that the sync protocol buffer doesn't
    // contain all SerializedNavigationEntry fields.
    void SetFromSyncData(const sync_pb::SessionTab& sync_data,
                         base::Time timestamp);
  
    // Convert this object into its sync protocol buffer equivalent.
    // Uses SerializedNavigationEntry::ToSyncData to convert |navigations|.  Note
    // that the protocol buffer doesn't contain all SerializedNavigationEntry
    // fields, and that the returned protocol buffer doesn't have any
    // favicon data.
    sync_pb::SessionTab ToSyncData() const;
  
    // Unique id of the window.
    SessionID window_id;
  
    // Unique if of the tab.
    SessionID tab_id;
  
    // Visual index of the tab within its window. There may be gaps in these
    // values.
    //
    // NOTE: this is really only useful for the SessionService during
    // restore, others can likely ignore this and use the order of the
    // tabs in SessionWindow.tabs.
    int tab_visual_index;
  
    // Identifies the index of the current navigation in navigations. For
    // example, if this is 2 it means the current navigation is navigations[2].
    //
    // NOTE: when the service is creating SessionTabs, initially this corresponds
    // to SerializedNavigationEntry.index, not the index in navigations. When done
    // creating though, this is set to the index in navigations.
    //
    // NOTE 2: this value can be larger than the size of |navigations|, due to
    // only valid url's being stored (ie chrome://newtab is not stored). Bounds
    // checking must be performed before indexing into |navigations|.
    int current_navigation_index;
  
    // True if the tab is pinned.
    bool pinned;
  
    // If non-empty, this tab is an app tab and this is the id of the extension.
    std::string extension_app_id;
  
    // If non-empty, this string is used as the user agent whenever the tab's
    // NavigationEntries need it overridden.
    std::string user_agent_override;
  
    // Timestamp for when this tab was last modified.
    base::Time timestamp;
  
    std::vector<sessions::SerializedNavigationEntry> navigations;
  
    // For reassociating sessionStorage.
    std::string session_storage_persistent_id;
  
   private:
    DISALLOW_COPY_AND_ASSIGN(SessionTab);
  };
  
  // SessionWindow -------------------------------------------------------------
  
  // Describes a saved window.
  struct SessionWindow {
    SessionWindow();
    ~SessionWindow();
  
    // Convert this object into its sync protocol buffer equivalent. Note that
    // not all fields are synced here, because they don't all make sense or
    // translate when restoring a SessionWindow on another device.
    sync_pb::SessionWindow ToSyncData() const;
  
    // Identifier of the window.
    SessionID window_id;
  
    // Bounds of the window.
    gfx::Rect bounds;
  
    // Index of the selected tab in tabs; -1 if no tab is selected. After restore
    // this value is guaranteed to be a valid index into tabs.
    //
    // NOTE: when the service is creating SessionWindows, initially this
    // corresponds to SessionTab.tab_visual_index, not the index in
    // tabs. When done creating though, this is set to the index in
    // tabs.
    int selected_tab_index;
  
    // Type of the browser. Currently we only store browsers of type
    // TYPE_TABBED and TYPE_POPUP.
    // This would be Browser::Type, but that would cause a circular dependency.
    int type;
  
    // If true, the window is constrained.
    //
    // Currently SessionService prunes all constrained windows so that session
    // restore does not attempt to restore them.
    bool is_constrained;
  
    // Timestamp for when this window was last modified.
    base::Time timestamp;
  
    // The tabs, ordered by visual order.
    std::vector<SessionTab*> tabs;
  
    // Is the window maximized, minimized, or normal?
    ui::WindowShowState show_state;
  
    std::string app_name;
  
   private:
    DISALLOW_COPY_AND_ASSIGN(SessionWindow);
  };
  
  #endif  // CHROME_BROWSER_SESSIONS_SESSION_TYPES_H_
  