1// Copyright (c) 2011 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/prefs/session_startup_pref.h"
6
7#include <string>
8
9#include "base/string_piece.h"
10#include "base/utf_string_conversions.h"
11#include "chrome/browser/defaults.h"
12#include "chrome/browser/net/url_fixer_upper.h"
13#include "chrome/browser/prefs/pref_service.h"
14#include "chrome/browser/prefs/scoped_user_pref_update.h"
15#include "chrome/browser/profiles/profile.h"
16#include "chrome/common/pref_names.h"
17
18namespace {
19
20// For historical reasons the enum and value registered in the prefs don't line
21// up. These are the values registered in prefs.
22const int kPrefValueDefault = 0;
23const int kPrefValueLast = 1;
24const int kPrefValueURLs = 4;
25
26// Converts a SessionStartupPref::Type to an integer written to prefs.
27int TypeToPrefValue(SessionStartupPref::Type type) {
28  switch (type) {
29    case SessionStartupPref::LAST:   return kPrefValueLast;
30    case SessionStartupPref::URLS:   return kPrefValueURLs;
31    default:                         return kPrefValueDefault;
32  }
33}
34
35// Converts an integer pref value to a SessionStartupPref::Type.
36SessionStartupPref::Type PrefValueToType(int pref_value) {
37  switch (pref_value) {
38    case kPrefValueLast:  return SessionStartupPref::LAST;
39    case kPrefValueURLs:  return SessionStartupPref::URLS;
40    default:              return SessionStartupPref::DEFAULT;
41  }
42}
43
44}  // namespace
45
46// static
47void SessionStartupPref::RegisterUserPrefs(PrefService* prefs) {
48  prefs->RegisterIntegerPref(prefs::kRestoreOnStartup,
49      TypeToPrefValue(browser_defaults::kDefaultSessionStartupType));
50  prefs->RegisterListPref(prefs::kURLsToRestoreOnStartup);
51}
52
53// static
54void SessionStartupPref::SetStartupPref(
55    Profile* profile,
56    const SessionStartupPref& pref) {
57  DCHECK(profile);
58  SetStartupPref(profile->GetPrefs(), pref);
59}
60
61// static
62void SessionStartupPref::SetStartupPref(PrefService* prefs,
63                                        const SessionStartupPref& pref) {
64  DCHECK(prefs);
65
66  if (!SessionStartupPref::TypeIsManaged(prefs))
67    prefs->SetInteger(prefs::kRestoreOnStartup, TypeToPrefValue(pref.type));
68
69  if (!SessionStartupPref::URLsAreManaged(prefs)) {
70    // Always save the URLs, that way the UI can remain consistent even if the
71    // user changes the startup type pref.
72    // Ownership of the ListValue retains with the pref service.
73    ListPrefUpdate update(prefs, prefs::kURLsToRestoreOnStartup);
74    ListValue* url_pref_list = update.Get();
75    DCHECK(url_pref_list);
76    url_pref_list->Clear();
77    for (size_t i = 0; i < pref.urls.size(); ++i) {
78      url_pref_list->Set(static_cast<int>(i),
79                         new StringValue(pref.urls[i].spec()));
80    }
81  }
82}
83
84// static
85SessionStartupPref SessionStartupPref::GetStartupPref(Profile* profile) {
86  DCHECK(profile);
87  return GetStartupPref(profile->GetPrefs());
88}
89
90// static
91SessionStartupPref SessionStartupPref::GetStartupPref(PrefService* prefs) {
92  DCHECK(prefs);
93  SessionStartupPref pref(
94      PrefValueToType(prefs->GetInteger(prefs::kRestoreOnStartup)));
95
96  // Always load the urls, even if the pref type isn't URLS. This way the
97  // preferences panels can show the user their last choice.
98  const ListValue* url_pref_list = prefs->GetList(
99      prefs::kURLsToRestoreOnStartup);
100  if (url_pref_list) {
101    for (size_t i = 0; i < url_pref_list->GetSize(); ++i) {
102      Value* value = NULL;
103      if (url_pref_list->Get(i, &value)) {
104        std::string url_text;
105        if (value->GetAsString(&url_text)) {
106          GURL fixed_url = URLFixerUpper::FixupURL(url_text, "");
107          pref.urls.push_back(fixed_url);
108        }
109      }
110    }
111  }
112  return pref;
113}
114
115// static
116bool SessionStartupPref::TypeIsManaged(PrefService* prefs) {
117  DCHECK(prefs);
118  const PrefService::Preference* pref_restore =
119      prefs->FindPreference(prefs::kRestoreOnStartup);
120  DCHECK(pref_restore);
121  return pref_restore->IsManaged();
122}
123
124// static
125bool SessionStartupPref::URLsAreManaged(PrefService* prefs) {
126  DCHECK(prefs);
127  const PrefService::Preference* pref_urls =
128      prefs->FindPreference(prefs::kURLsToRestoreOnStartup);
129  DCHECK(pref_urls);
130  return pref_urls->IsManaged();
131}
132
133SessionStartupPref::SessionStartupPref() : type(DEFAULT) {}
134
135SessionStartupPref::SessionStartupPref(Type type) : type(type) {}
136
137SessionStartupPref::~SessionStartupPref() {}
138