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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// 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.
#include "chrome/browser/ui/browser_window_state.h"
#include "base/command_line.h"
#include "base/string_number_conversions.h"
#include "chrome/browser/defaults.h"
#include "chrome/browser/prefs/pref_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/sessions/session_service.h"
#include "chrome/browser/sessions/session_service_factory.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/window_sizer/window_sizer.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/pref_names.h"
namespace chrome {
namespace {
// Parse two comma-separated integers from str. Return true on success.
bool ParseCommaSeparatedIntegers(const std::string& str,
int* ret_num1,
int* ret_num2) {
size_t num1_size = str.find_first_of(',');
if (num1_size == std::string::npos)
return false;
size_t num2_pos = num1_size + 1;
size_t num2_size = str.size() - num2_pos;
int num1, num2;
if (!base::StringToInt(str.substr(0, num1_size), &num1) ||
!base::StringToInt(str.substr(num2_pos, num2_size), &num2))
return false;
*ret_num1 = num1;
*ret_num2 = num2;
return true;
}
} // namespace
std::string GetWindowPlacementKey(const Browser* browser) {
std::string name(prefs::kBrowserWindowPlacement);
if (!browser->app_name().empty()) {
name.append("_");
name.append(browser->app_name());
}
return name;
}
bool ShouldSaveWindowPlacement(const Browser* browser) {
switch (browser->type()) {
case Browser::TYPE_TABBED:
return true;
case Browser::TYPE_POPUP:
// Only save the window placement of popups if they are restored,
// or the window belongs to DevTools or an App.
return browser_defaults::kRestorePopups || browser->is_devtools() ||
browser->is_app();
case Browser::TYPE_PANEL:
// Do not save the window placement of panels.
return false;
default:
return false;
}
}
void SaveWindowPlacement(const Browser* browser,
const gfx::Rect& bounds,
ui::WindowShowState show_state) {
// Save to the session storage service, used when reloading a past session.
// Note that we don't want to be the ones who cause lazy initialization of
// the session service. This function gets called during initial window
// showing, and we don't want to bring in the session service this early.
SessionService* session_service =
SessionServiceFactory::GetForProfileIfExisting(browser->profile());
if (session_service)
session_service->SetWindowBounds(browser->session_id(), bounds, show_state);
}
gfx::Rect GetSavedWindowBounds(const Browser* browser) {
gfx::Rect restored_bounds = browser->override_bounds();
WindowSizer::GetBrowserWindowBounds(browser->app_name(),
restored_bounds,
browser,
&restored_bounds);
const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
bool record_mode = parsed_command_line.HasSwitch(switches::kRecordMode);
bool playback_mode = parsed_command_line.HasSwitch(switches::kPlaybackMode);
if (record_mode || playback_mode) {
// In playback/record mode we always fix the size of the browser and
// move it to (0,0). The reason for this is two reasons: First we want
// resize/moves in the playback to still work, and Second we want
// playbacks to work (as much as possible) on machines w/ different
// screen sizes.
restored_bounds = gfx::Rect(0, 0, 800, 600);
}
// The following options override playback/record.
if (parsed_command_line.HasSwitch(switches::kWindowSize)) {
std::string str =
parsed_command_line.GetSwitchValueASCII(switches::kWindowSize);
int width, height;
if (ParseCommaSeparatedIntegers(str, &width, &height))
restored_bounds.set_size(gfx::Size(width, height));
}
if (parsed_command_line.HasSwitch(switches::kWindowPosition)) {
std::string str =
parsed_command_line.GetSwitchValueASCII(switches::kWindowPosition);
int x, y;
if (ParseCommaSeparatedIntegers(str, &x, &y))
restored_bounds.set_origin(gfx::Point(x, y));
}
return restored_bounds;
}
ui::WindowShowState GetSavedWindowShowState(const Browser* browser) {
// Only tabbed browsers use the command line or preference state, with the
// exception of devtools.
bool show_state = !browser->is_type_tabbed() && !browser->is_devtools();
#if defined(USE_AURA)
// Apps save state on aura.
show_state &= !browser->is_app();
#endif
if (show_state)
return browser->initial_show_state();
if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kStartMaximized))
return ui::SHOW_STATE_MAXIMIZED;
if (browser->initial_show_state() != ui::SHOW_STATE_DEFAULT)
return browser->initial_show_state();
const DictionaryValue* window_pref = browser->profile()->GetPrefs()->
GetDictionary(GetWindowPlacementKey(browser).c_str());
bool maximized = false;
window_pref->GetBoolean("maximized", &maximized);
return maximized ? ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_DEFAULT;
}
} // namespace chrome
|
