1 // Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights
2 // reserved. Use of this source code is governed by a BSD-style license that
3 // can be found in the LICENSE file.
4
5 #include "tests/cefclient/browser/main_context_impl.h"
6
7 #include "include/cef_parser.h"
8 #include "include/cef_web_plugin.h"
9 #include "tests/shared/browser/client_app_browser.h"
10 #include "tests/shared/common/client_switches.h"
11
12 namespace client {
13
14 namespace {
15
16 // The default URL to load in a browser window.
17 const char kDefaultUrl[] = "http://www.google.com";
18
19 // Returns the ARGB value for |color|.
ParseColor(const std::string & color)20 cef_color_t ParseColor(const std::string& color) {
21 std::string colorToLower;
22 colorToLower.resize(color.size());
23 std::transform(color.begin(), color.end(), colorToLower.begin(), ::tolower);
24
25 if (colorToLower == "black")
26 return CefColorSetARGB(255, 0, 0, 0);
27 else if (colorToLower == "blue")
28 return CefColorSetARGB(255, 0, 0, 255);
29 else if (colorToLower == "green")
30 return CefColorSetARGB(255, 0, 255, 0);
31 else if (colorToLower == "red")
32 return CefColorSetARGB(255, 255, 0, 0);
33 else if (colorToLower == "white")
34 return CefColorSetARGB(255, 255, 255, 255);
35
36 // Use the default color.
37 return 0;
38 }
39
40 } // namespace
41
MainContextImpl(CefRefPtr<CefCommandLine> command_line,bool terminate_when_all_windows_closed)42 MainContextImpl::MainContextImpl(CefRefPtr<CefCommandLine> command_line,
43 bool terminate_when_all_windows_closed)
44 : command_line_(command_line),
45 terminate_when_all_windows_closed_(terminate_when_all_windows_closed),
46 initialized_(false),
47 shutdown_(false),
48 background_color_(0),
49 browser_background_color_(0),
50 windowless_frame_rate_(0),
51 use_views_(false) {
52 DCHECK(command_line_.get());
53
54 // Set the main URL.
55 if (command_line_->HasSwitch(switches::kUrl))
56 main_url_ = command_line_->GetSwitchValue(switches::kUrl);
57 if (main_url_.empty())
58 main_url_ = kDefaultUrl;
59
60 // Whether windowless (off-screen) rendering will be used.
61 use_windowless_rendering_ =
62 command_line_->HasSwitch(switches::kOffScreenRenderingEnabled);
63
64 if (use_windowless_rendering_ &&
65 command_line_->HasSwitch(switches::kOffScreenFrameRate)) {
66 windowless_frame_rate_ =
67 atoi(command_line_->GetSwitchValue(switches::kOffScreenFrameRate)
68 .ToString()
69 .c_str());
70 }
71
72 // Whether transparent painting is used with windowless rendering.
73 const bool use_transparent_painting =
74 use_windowless_rendering_ &&
75 command_line_->HasSwitch(switches::kTransparentPaintingEnabled);
76
77 #if defined(OS_WIN)
78 // Shared texture is only supported on Windows.
79 shared_texture_enabled_ =
80 use_windowless_rendering_ &&
81 command_line_->HasSwitch(switches::kSharedTextureEnabled);
82 #endif
83
84 external_begin_frame_enabled_ =
85 use_windowless_rendering_ &&
86 command_line_->HasSwitch(switches::kExternalBeginFrameEnabled);
87
88 if (windowless_frame_rate_ <= 0) {
89 // Choose a reasonable default rate based on the OSR mode.
90 #if defined(OS_WIN)
91 windowless_frame_rate_ = shared_texture_enabled_ ? 60 : 30;
92 #else
93 windowless_frame_rate_ = 30;
94 #endif
95 }
96
97 // Enable experimental Chrome runtime. See issue #2969 for details.
98 use_chrome_runtime_ =
99 command_line_->HasSwitch(switches::kEnableChromeRuntime);
100
101 if (use_windowless_rendering_ && use_chrome_runtime_) {
102 LOG(ERROR)
103 << "Windowless rendering is not supported with the Chrome runtime.";
104 use_chrome_runtime_ = false;
105 }
106
107 // Whether the Views framework will be used.
108 use_views_ = command_line_->HasSwitch(switches::kUseViews);
109
110 if (use_windowless_rendering_ && use_views_) {
111 LOG(ERROR)
112 << "Windowless rendering is not supported by the Views framework.";
113 use_views_ = false;
114 }
115
116 if (use_chrome_runtime_ && !use_views_) {
117 // TODO(chrome): Add support for this runtime configuration (e.g. a fully
118 // styled Chrome window with cefclient menu customizations). In the mean
119 // time this can be demo'd with "cefsimple --enable-chrome-runtime".
120 LOG(WARNING) << "Chrome runtime requires the Views framework.";
121 use_views_ = true;
122 }
123
124 if (use_views_ && command_line->HasSwitch(switches::kHideFrame) &&
125 !command_line_->HasSwitch(switches::kUrl)) {
126 // Use the draggable regions test as the default URL for frameless windows.
127 main_url_ = "http://tests/draggable";
128 }
129
130 if (command_line_->HasSwitch(switches::kBackgroundColor)) {
131 // Parse the background color value.
132 background_color_ =
133 ParseColor(command_line_->GetSwitchValue(switches::kBackgroundColor));
134 }
135
136 if (background_color_ == 0 && !use_views_) {
137 // Set an explicit background color.
138 background_color_ = CefColorSetARGB(255, 255, 255, 255);
139 }
140
141 // |browser_background_color_| should remain 0 to enable transparent painting.
142 if (!use_transparent_painting) {
143 browser_background_color_ = background_color_;
144 }
145
146 const std::string& cdm_path =
147 command_line_->GetSwitchValue(switches::kWidevineCdmPath);
148 if (!cdm_path.empty()) {
149 // Register the Widevine CDM at the specified path. See comments in
150 // cef_web_plugin.h for details. It's safe to call this method before
151 // CefInitialize(), and calling it before CefInitialize() is required on
152 // Linux.
153 CefRegisterWidevineCdm(cdm_path, nullptr);
154 }
155 }
156
~MainContextImpl()157 MainContextImpl::~MainContextImpl() {
158 // The context must either not have been initialized, or it must have also
159 // been shut down.
160 DCHECK(!initialized_ || shutdown_);
161 }
162
GetConsoleLogPath()163 std::string MainContextImpl::GetConsoleLogPath() {
164 return GetAppWorkingDirectory() + "console.log";
165 }
166
GetMainURL()167 std::string MainContextImpl::GetMainURL() {
168 return main_url_;
169 }
170
GetBackgroundColor()171 cef_color_t MainContextImpl::GetBackgroundColor() {
172 return background_color_;
173 }
174
UseChromeRuntime()175 bool MainContextImpl::UseChromeRuntime() {
176 return use_chrome_runtime_;
177 }
178
UseViews()179 bool MainContextImpl::UseViews() {
180 return use_views_;
181 }
182
UseWindowlessRendering()183 bool MainContextImpl::UseWindowlessRendering() {
184 return use_windowless_rendering_;
185 }
186
TouchEventsEnabled()187 bool MainContextImpl::TouchEventsEnabled() {
188 return command_line_->GetSwitchValue("touch-events") == "enabled";
189 }
190
PopulateSettings(CefSettings * settings)191 void MainContextImpl::PopulateSettings(CefSettings* settings) {
192 client::ClientAppBrowser::PopulateSettings(command_line_, *settings);
193
194 if (use_chrome_runtime_)
195 settings->chrome_runtime = true;
196
197 CefString(&settings->cache_path) =
198 command_line_->GetSwitchValue(switches::kCachePath);
199
200 if (use_windowless_rendering_)
201 settings->windowless_rendering_enabled = true;
202
203 if (browser_background_color_ != 0)
204 settings->background_color = browser_background_color_;
205
206 if (command_line_->HasSwitch("lang")) {
207 // Use the same locale for the Accept-Language HTTP request header.
208 CefString(&settings->accept_language_list) =
209 command_line_->GetSwitchValue("lang");
210 }
211 }
212
PopulateBrowserSettings(CefBrowserSettings * settings)213 void MainContextImpl::PopulateBrowserSettings(CefBrowserSettings* settings) {
214 settings->windowless_frame_rate = windowless_frame_rate_;
215
216 if (browser_background_color_ != 0)
217 settings->background_color = browser_background_color_;
218 }
219
PopulateOsrSettings(OsrRendererSettings * settings)220 void MainContextImpl::PopulateOsrSettings(OsrRendererSettings* settings) {
221 settings->show_update_rect =
222 command_line_->HasSwitch(switches::kShowUpdateRect);
223
224 #if defined(OS_WIN)
225 settings->shared_texture_enabled = shared_texture_enabled_;
226 #endif
227 settings->external_begin_frame_enabled = external_begin_frame_enabled_;
228 settings->begin_frame_rate = windowless_frame_rate_;
229
230 if (browser_background_color_ != 0)
231 settings->background_color = browser_background_color_;
232 }
233
GetRootWindowManager()234 RootWindowManager* MainContextImpl::GetRootWindowManager() {
235 DCHECK(InValidState());
236 return root_window_manager_.get();
237 }
238
Initialize(const CefMainArgs & args,const CefSettings & settings,CefRefPtr<CefApp> application,void * windows_sandbox_info)239 bool MainContextImpl::Initialize(const CefMainArgs& args,
240 const CefSettings& settings,
241 CefRefPtr<CefApp> application,
242 void* windows_sandbox_info) {
243 DCHECK(thread_checker_.CalledOnValidThread());
244 DCHECK(!initialized_);
245 DCHECK(!shutdown_);
246
247 if (!CefInitialize(args, settings, application, windows_sandbox_info))
248 return false;
249
250 // Need to create the RootWindowManager after calling CefInitialize because
251 // TempWindowX11 uses cef_get_xdisplay().
252 root_window_manager_.reset(
253 new RootWindowManager(terminate_when_all_windows_closed_));
254
255 initialized_ = true;
256
257 return true;
258 }
259
Shutdown()260 void MainContextImpl::Shutdown() {
261 DCHECK(thread_checker_.CalledOnValidThread());
262 DCHECK(initialized_);
263 DCHECK(!shutdown_);
264
265 root_window_manager_.reset();
266
267 CefShutdown();
268
269 shutdown_ = true;
270 }
271
272 } // namespace client
273