[email protected] | de7d61ff | 2013-08-20 11:30:41 | [diff] [blame] | 1 | // Copyright 2013 The Chromium Authors. All rights reserved. |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
[email protected] | de7d61ff | 2013-08-20 11:30:41 | [diff] [blame] | 5 | #include "content/shell/browser/shell.h" |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 6 | |
avi | 66a0772 | 2015-12-25 23:38:12 | [diff] [blame] | 7 | #include <stddef.h> |
| 8 | |
[email protected] | 11a65b69 | 2012-03-30 11:29:16 | [diff] [blame] | 9 | #include "base/auto_reset.h" |
[email protected] | efb5f57 | 2012-01-29 10:57:33 | [diff] [blame] | 10 | #include "base/command_line.h" |
skyostil | 95082a6 | 2015-06-05 19:53:07 | [diff] [blame] | 11 | #include "base/location.h" |
avi | 66a0772 | 2015-12-25 23:38:12 | [diff] [blame] | 12 | #include "base/macros.h" |
gab | f64a25e | 2017-05-12 19:42:56 | [diff] [blame] | 13 | #include "base/message_loop/message_loop.h" |
fdoray | 896bea1 | 2016-06-10 15:52:01 | [diff] [blame] | 14 | #include "base/run_loop.h" |
skyostil | 95082a6 | 2015-06-05 19:53:07 | [diff] [blame] | 15 | #include "base/single_thread_task_runner.h" |
[email protected] | 21aa9968 | 2013-06-11 07:17:01 | [diff] [blame] | 16 | #include "base/strings/string_number_conversions.h" |
| 17 | #include "base/strings/string_util.h" |
| 18 | #include "base/strings/stringprintf.h" |
[email protected] | 74ebfb1 | 2013-06-07 20:48:00 | [diff] [blame] | 19 | #include "base/strings/utf_string_conversions.h" |
gab | 30f26df | 2016-05-11 19:37:55 | [diff] [blame] | 20 | #include "base/threading/thread_task_runner_handle.h" |
avi | 66a0772 | 2015-12-25 23:38:12 | [diff] [blame] | 21 | #include "build/build_config.h" |
[email protected] | b50452f | 2014-08-18 12:31:44 | [diff] [blame] | 22 | #include "content/public/browser/devtools_agent_host.h" |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 23 | #include "content/public/browser/navigation_controller.h" |
[email protected] | b7c504c | 2013-05-07 14:42:12 | [diff] [blame] | 24 | #include "content/public/browser/navigation_entry.h" |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 25 | #include "content/public/browser/render_view_host.h" |
avi | f9ab5d94 | 2015-10-15 14:05:44 | [diff] [blame] | 26 | #include "content/public/browser/render_widget_host.h" |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 27 | #include "content/public/browser/web_contents.h" |
[email protected] | 7fff43e | 2013-05-21 20:21:10 | [diff] [blame] | 28 | #include "content/public/browser/web_contents_observer.h" |
guoweis | 8efb6d89 | 2015-10-12 18:26:17 | [diff] [blame] | 29 | #include "content/public/common/content_switches.h" |
[email protected] | 1596efb | 2013-01-17 22:13:01 | [diff] [blame] | 30 | #include "content/public/common/renderer_preferences.h" |
guoweis | c537ba2 | 2015-11-06 21:20:31 | [diff] [blame] | 31 | #include "content/public/common/webrtc_ip_handling_policy.h" |
jochen | 5ce1af9 | 2016-02-17 20:39:45 | [diff] [blame] | 32 | #include "content/shell/browser/layout_test/blink_test_controller.h" |
jyasskin | 8057c00 | 2015-09-10 19:09:53 | [diff] [blame] | 33 | #include "content/shell/browser/layout_test/layout_test_bluetooth_chooser_factory.h" |
chenwilliam | fed5bda | 2017-03-24 02:01:06 | [diff] [blame] | 34 | #include "content/shell/browser/layout_test/layout_test_devtools_bindings.h" |
mkwst | 6efe7f2e6 | 2014-10-08 15:09:01 | [diff] [blame] | 35 | #include "content/shell/browser/layout_test/layout_test_javascript_dialog_manager.h" |
lukasza | 8e550a0 | 2016-04-18 18:34:17 | [diff] [blame] | 36 | #include "content/shell/browser/layout_test/secondary_test_window_observer.h" |
[email protected] | de7d61ff | 2013-08-20 11:30:41 | [diff] [blame] | 37 | #include "content/shell/browser/shell_browser_main_parts.h" |
| 38 | #include "content/shell/browser/shell_content_browser_client.h" |
| 39 | #include "content/shell/browser/shell_devtools_frontend.h" |
| 40 | #include "content/shell/browser/shell_javascript_dialog_manager.h" |
carlosk | d9d9794 | 2017-02-16 08:58:09 | [diff] [blame] | 41 | #include "content/shell/common/layout_test/layout_test_switches.h" |
[email protected] | b7c504c | 2013-05-07 14:42:12 | [diff] [blame] | 42 | #include "content/shell/common/shell_messages.h" |
| 43 | #include "content/shell/common/shell_switches.h" |
Brett Wilson | 0748bf41 | 2016-11-22 17:55:46 | [diff] [blame] | 44 | #include "media/media_features.h" |
mark a. foltz | ef394fce | 2017-10-21 09:11:02 | [diff] [blame] | 45 | #include "third_party/WebKit/public/web/WebPresentationReceiverFlags.h" |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 46 | |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 47 | namespace content { |
| 48 | |
pdr | cab84ee | 2015-03-13 21:47:04 | [diff] [blame] | 49 | const int kDefaultTestWindowWidthDip = 800; |
| 50 | const int kDefaultTestWindowHeightDip = 600; |
[email protected] | 1e57cab | 2013-05-28 04:26:11 | [diff] [blame] | 51 | |
[email protected] | e99ca511 | 2011-09-26 17:22:54 | [diff] [blame] | 52 | std::vector<Shell*> Shell::windows_; |
[email protected] | 9e00e635 | 2012-07-30 17:05:18 | [diff] [blame] | 53 | base::Callback<void(Shell*)> Shell::shell_created_callback_; |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 54 | |
[email protected] | 11a65b69 | 2012-03-30 11:29:16 | [diff] [blame] | 55 | bool Shell::quit_message_loop_ = true; |
| 56 | |
[email protected] | 7fff43e | 2013-05-21 20:21:10 | [diff] [blame] | 57 | class Shell::DevToolsWebContentsObserver : public WebContentsObserver { |
| 58 | public: |
| 59 | DevToolsWebContentsObserver(Shell* shell, WebContents* web_contents) |
| 60 | : WebContentsObserver(web_contents), |
| 61 | shell_(shell) { |
| 62 | } |
| 63 | |
| 64 | // WebContentsObserver |
dcheng | e933b3e | 2014-10-21 11:44:09 | [diff] [blame] | 65 | void WebContentsDestroyed() override { |
[email protected] | 7fff43e | 2013-05-21 20:21:10 | [diff] [blame] | 66 | shell_->OnDevToolsWebContentsDestroyed(); |
| 67 | } |
| 68 | |
| 69 | private: |
| 70 | Shell* shell_; |
| 71 | |
| 72 | DISALLOW_COPY_AND_ASSIGN(DevToolsWebContentsObserver); |
| 73 | }; |
| 74 | |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 75 | Shell::Shell(WebContents* web_contents) |
[email protected] | 1ef02d24 | 2013-10-07 16:18:53 | [diff] [blame] | 76 | : WebContentsObserver(web_contents), |
arthursonzogni | fdd4991 | 2017-08-31 08:55:26 | [diff] [blame] | 77 | web_contents_(web_contents), |
Ivan Kotenkov | 2c0d2bb3 | 2017-11-01 15:41:28 | [diff] [blame] | 78 | devtools_frontend_(nullptr), |
[email protected] | 001841c9 | 2012-12-11 17:00:13 | [diff] [blame] | 79 | is_fullscreen_(false), |
Ivan Kotenkov | 2c0d2bb3 | 2017-11-01 15:41:28 | [diff] [blame] | 80 | window_(nullptr), |
sadrul | 8b11d26 | 2015-11-12 18:41:33 | [diff] [blame] | 81 | #if defined(OS_MACOSX) |
[email protected] | 86b36e67 | 2012-12-21 00:09:51 | [diff] [blame] | 82 | url_edit_view_(NULL), |
sadrul | 8b11d26 | 2015-11-12 18:41:33 | [diff] [blame] | 83 | #endif |
Pavel Feldman | c7cd063c | 2017-10-06 20:04:28 | [diff] [blame] | 84 | headless_(false), |
| 85 | hide_toolbar_(false) { |
arthursonzogni | fdd4991 | 2017-08-31 08:55:26 | [diff] [blame] | 86 | web_contents_->SetDelegate(this); |
| 87 | |
lukasza | 381b049 | 2016-03-10 16:48:43 | [diff] [blame] | 88 | if (switches::IsRunLayoutTestSwitchPresent()) |
[email protected] | 86b36e67 | 2012-12-21 00:09:51 | [diff] [blame] | 89 | headless_ = true; |
Pavel Feldman | c7cd063c | 2017-10-06 20:04:28 | [diff] [blame] | 90 | |
| 91 | if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| 92 | switches::kContentShellHideToolbar)) |
| 93 | hide_toolbar_ = true; |
| 94 | |
[email protected] | 9e00e635 | 2012-07-30 17:05:18 | [diff] [blame] | 95 | windows_.push_back(this); |
| 96 | |
| 97 | if (!shell_created_callback_.is_null()) { |
| 98 | shell_created_callback_.Run(this); |
| 99 | shell_created_callback_.Reset(); |
| 100 | } |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 101 | } |
| 102 | |
| 103 | Shell::~Shell() { |
| 104 | PlatformCleanUp(); |
[email protected] | e99ca511 | 2011-09-26 17:22:54 | [diff] [blame] | 105 | |
| 106 | for (size_t i = 0; i < windows_.size(); ++i) { |
| 107 | if (windows_[i] == this) { |
| 108 | windows_.erase(windows_.begin() + i); |
| 109 | break; |
| 110 | } |
| 111 | } |
[email protected] | 11a65b69 | 2012-03-30 11:29:16 | [diff] [blame] | 112 | |
[email protected] | b53adf45 | 2014-02-07 12:55:08 | [diff] [blame] | 113 | if (windows_.empty() && quit_message_loop_) { |
| 114 | if (headless_) |
| 115 | PlatformExit(); |
skyostil | 95082a6 | 2015-06-05 19:53:07 | [diff] [blame] | 116 | base::ThreadTaskRunnerHandle::Get()->PostTask( |
ki.stfu | 80077924 | 2015-10-12 22:46:26 | [diff] [blame] | 117 | FROM_HERE, base::MessageLoop::QuitWhenIdleClosure()); |
[email protected] | b53adf45 | 2014-02-07 12:55:08 | [diff] [blame] | 118 | } |
arthursonzogni | fdd4991 | 2017-08-31 08:55:26 | [diff] [blame] | 119 | |
| 120 | web_contents_->SetDelegate(nullptr); |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 121 | } |
| 122 | |
[email protected] | c0d036d | 2013-05-07 12:50:50 | [diff] [blame] | 123 | Shell* Shell::CreateShell(WebContents* web_contents, |
| 124 | const gfx::Size& initial_size) { |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 125 | Shell* shell = new Shell(web_contents); |
[email protected] | c0d036d | 2013-05-07 12:50:50 | [diff] [blame] | 126 | shell->PlatformCreateWindow(initial_size.width(), initial_size.height()); |
[email protected] | 3fd8403 | 2012-01-12 18:20:17 | [diff] [blame] | 127 | |
[email protected] | 5cba3bf | 2012-01-14 02:40:35 | [diff] [blame] | 128 | shell->PlatformSetContents(); |
[email protected] | 3fd8403 | 2012-01-12 18:20:17 | [diff] [blame] | 129 | |
| 130 | shell->PlatformResizeSubViews(); |
[email protected] | 1596efb | 2013-01-17 22:13:01 | [diff] [blame] | 131 | |
creis | b6561df | 2016-02-11 20:20:54 | [diff] [blame] | 132 | // Note: Do not make RenderFrameHost or RenderViewHost specific state changes |
| 133 | // here, because they will be forgotten after a cross-process navigation. Use |
| 134 | // RenderFrameCreated or RenderViewCreated instead. |
lukasza | 381b049 | 2016-03-10 16:48:43 | [diff] [blame] | 135 | if (switches::IsRunLayoutTestSwitchPresent()) { |
[email protected] | 1596efb | 2013-01-17 22:13:01 | [diff] [blame] | 136 | web_contents->GetMutableRendererPrefs()->use_custom_colors = false; |
| 137 | web_contents->GetRenderViewHost()->SyncRendererPrefs(); |
| 138 | } |
| 139 | |
Brett Wilson | 0748bf41 | 2016-11-22 17:55:46 | [diff] [blame] | 140 | #if BUILDFLAG(ENABLE_WEBRTC) |
lukasza | 381b049 | 2016-03-10 16:48:43 | [diff] [blame] | 141 | base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); |
guoweis | 4ee4859 | 2015-12-02 06:37:07 | [diff] [blame] | 142 | if (command_line->HasSwitch(switches::kForceWebRtcIPHandlingPolicy)) { |
guoweis | c537ba2 | 2015-11-06 21:20:31 | [diff] [blame] | 143 | web_contents->GetMutableRendererPrefs()->webrtc_ip_handling_policy = |
guoweis | 4ee4859 | 2015-12-02 06:37:07 | [diff] [blame] | 144 | command_line->GetSwitchValueASCII( |
| 145 | switches::kForceWebRtcIPHandlingPolicy); |
guoweis | 8efb6d89 | 2015-10-12 18:26:17 | [diff] [blame] | 146 | } |
| 147 | #endif |
| 148 | |
[email protected] | 3fd8403 | 2012-01-12 18:20:17 | [diff] [blame] | 149 | return shell; |
| 150 | } |
| 151 | |
[email protected] | 11a65b69 | 2012-03-30 11:29:16 | [diff] [blame] | 152 | void Shell::CloseAllWindows() { |
[email protected] | 997ec9f | 2012-11-21 04:44:14 | [diff] [blame] | 153 | base::AutoReset<bool> auto_reset(&quit_message_loop_, false); |
[email protected] | b50452f | 2014-08-18 12:31:44 | [diff] [blame] | 154 | DevToolsAgentHost::DetachAllClients(); |
[email protected] | 11a65b69 | 2012-03-30 11:29:16 | [diff] [blame] | 155 | std::vector<Shell*> open_windows(windows_); |
| 156 | for (size_t i = 0; i < open_windows.size(); ++i) |
| 157 | open_windows[i]->Close(); |
fdoray | 896bea1 | 2016-06-10 15:52:01 | [diff] [blame] | 158 | base::RunLoop().RunUntilIdle(); |
dmazzoni | 948fbc7 | 2015-05-17 07:57:33 | [diff] [blame] | 159 | PlatformExit(); |
[email protected] | 11a65b69 | 2012-03-30 11:29:16 | [diff] [blame] | 160 | } |
| 161 | |
[email protected] | 9e00e635 | 2012-07-30 17:05:18 | [diff] [blame] | 162 | void Shell::SetShellCreatedCallback( |
| 163 | base::Callback<void(Shell*)> shell_created_callback) { |
| 164 | DCHECK(shell_created_callback_.is_null()); |
| 165 | shell_created_callback_ = shell_created_callback; |
| 166 | } |
| 167 | |
[email protected] | 74830f0 | 2012-01-30 22:27:04 | [diff] [blame] | 168 | Shell* Shell::FromRenderViewHost(RenderViewHost* rvh) { |
| 169 | for (size_t i = 0; i < windows_.size(); ++i) { |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 170 | if (windows_[i]->web_contents() && |
| 171 | windows_[i]->web_contents()->GetRenderViewHost() == rvh) { |
[email protected] | 74830f0 | 2012-01-30 22:27:04 | [diff] [blame] | 172 | return windows_[i]; |
| 173 | } |
| 174 | } |
Ivan Kotenkov | 2c0d2bb3 | 2017-11-01 15:41:28 | [diff] [blame] | 175 | return nullptr; |
[email protected] | 74830f0 | 2012-01-30 22:27:04 | [diff] [blame] | 176 | } |
| 177 | |
[email protected] | 6153b27 | 2013-01-25 22:29:23 | [diff] [blame] | 178 | // static |
| 179 | void Shell::Initialize() { |
pdr | cab84ee | 2015-03-13 21:47:04 | [diff] [blame] | 180 | PlatformInitialize(GetShellDefaultSize()); |
[email protected] | 6153b27 | 2013-01-25 22:29:23 | [diff] [blame] | 181 | } |
| 182 | |
[email protected] | a290409 | 2013-10-15 04:53:59 | [diff] [blame] | 183 | gfx::Size Shell::AdjustWindowSize(const gfx::Size& initial_size) { |
| 184 | if (!initial_size.IsEmpty()) |
| 185 | return initial_size; |
pdr | cab84ee | 2015-03-13 21:47:04 | [diff] [blame] | 186 | return GetShellDefaultSize(); |
[email protected] | a290409 | 2013-10-15 04:53:59 | [diff] [blame] | 187 | } |
| 188 | |
[email protected] | bdcf915 | 2012-07-19 17:43:21 | [diff] [blame] | 189 | Shell* Shell::CreateNewWindow(BrowserContext* browser_context, |
[email protected] | e99ca511 | 2011-09-26 17:22:54 | [diff] [blame] | 190 | const GURL& url, |
lukasza | 0413015 | 2016-10-21 20:26:32 | [diff] [blame] | 191 | const scoped_refptr<SiteInstance>& site_instance, |
[email protected] | cdb80672 | 2013-01-10 14:18:23 | [diff] [blame] | 192 | const gfx::Size& initial_size) { |
[email protected] | 54944cde | 2012-12-09 09:24:59 | [diff] [blame] | 193 | WebContents::CreateParams create_params(browser_context, site_instance); |
mark a. foltz | ef394fce | 2017-10-21 09:11:02 | [diff] [blame] | 194 | if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| 195 | switches::kForcePresentationReceiverForTesting)) { |
| 196 | create_params.starting_sandbox_flags = |
| 197 | blink::kPresentationReceiverSandboxFlags; |
| 198 | } |
[email protected] | a290409 | 2013-10-15 04:53:59 | [diff] [blame] | 199 | create_params.initial_size = AdjustWindowSize(initial_size); |
[email protected] | 54944cde | 2012-12-09 09:24:59 | [diff] [blame] | 200 | WebContents* web_contents = WebContents::Create(create_params); |
[email protected] | c0d036d | 2013-05-07 12:50:50 | [diff] [blame] | 201 | Shell* shell = CreateShell(web_contents, create_params.initial_size); |
[email protected] | e99ca511 | 2011-09-26 17:22:54 | [diff] [blame] | 202 | if (!url.is_empty()) |
| 203 | shell->LoadURL(url); |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 204 | return shell; |
| 205 | } |
| 206 | |
| 207 | void Shell::LoadURL(const GURL& url) { |
[email protected] | d2494ff | 2013-02-20 08:22:37 | [diff] [blame] | 208 | LoadURLForFrame(url, std::string()); |
| 209 | } |
| 210 | |
| 211 | void Shell::LoadURLForFrame(const GURL& url, const std::string& frame_name) { |
| 212 | NavigationController::LoadURLParams params(url); |
Sylvain Defresne | c6ccc77d | 2014-09-19 10:19:35 | [diff] [blame] | 213 | params.transition_type = ui::PageTransitionFromInt( |
| 214 | ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR); |
[email protected] | d2494ff | 2013-02-20 08:22:37 | [diff] [blame] | 215 | params.frame_name = frame_name; |
| 216 | web_contents_->GetController().LoadURLWithParams(params); |
[email protected] | fc2b46b | 2014-05-03 16:33:45 | [diff] [blame] | 217 | web_contents_->Focus(); |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 218 | } |
| 219 | |
[email protected] | 76bdecb | 2014-04-16 17:58:08 | [diff] [blame] | 220 | void Shell::LoadDataWithBaseURL(const GURL& url, const std::string& data, |
| 221 | const GURL& base_url) { |
boliu | ec93ea9 | 2016-02-17 22:23:07 | [diff] [blame] | 222 | bool load_as_string = false; |
| 223 | LoadDataWithBaseURLInternal(url, data, base_url, load_as_string); |
| 224 | } |
| 225 | |
| 226 | #if defined(OS_ANDROID) |
| 227 | void Shell::LoadDataAsStringWithBaseURL(const GURL& url, |
| 228 | const std::string& data, |
| 229 | const GURL& base_url) { |
| 230 | bool load_as_string = true; |
| 231 | LoadDataWithBaseURLInternal(url, data, base_url, load_as_string); |
| 232 | } |
| 233 | #endif |
| 234 | |
| 235 | void Shell::LoadDataWithBaseURLInternal(const GURL& url, |
| 236 | const std::string& data, |
| 237 | const GURL& base_url, |
| 238 | bool load_as_string) { |
| 239 | #if !defined(OS_ANDROID) |
| 240 | DCHECK(!load_as_string); // Only supported on Android. |
| 241 | #endif |
| 242 | |
| 243 | NavigationController::LoadURLParams params(GURL::EmptyGURL()); |
| 244 | const std::string data_url_header = "data:text/html;charset=utf-8,"; |
| 245 | if (load_as_string) { |
| 246 | params.url = GURL(data_url_header); |
| 247 | std::string data_url_as_string = data_url_header + data; |
| 248 | #if defined(OS_ANDROID) |
| 249 | params.data_url_as_string = |
| 250 | base::RefCountedString::TakeString(&data_url_as_string); |
| 251 | #endif |
| 252 | } else { |
| 253 | params.url = GURL(data_url_header + data); |
| 254 | } |
| 255 | |
[email protected] | 76bdecb | 2014-04-16 17:58:08 | [diff] [blame] | 256 | params.load_type = NavigationController::LOAD_TYPE_DATA; |
| 257 | params.base_url_for_data_url = base_url; |
| 258 | params.virtual_url_for_data_url = url; |
| 259 | params.override_user_agent = NavigationController::UA_OVERRIDE_FALSE; |
| 260 | web_contents_->GetController().LoadURLWithParams(params); |
[email protected] | fc2b46b | 2014-05-03 16:33:45 | [diff] [blame] | 261 | web_contents_->Focus(); |
[email protected] | 76bdecb | 2014-04-16 17:58:08 | [diff] [blame] | 262 | } |
| 263 | |
[email protected] | a290409 | 2013-10-15 04:53:59 | [diff] [blame] | 264 | void Shell::AddNewContents(WebContents* source, |
| 265 | WebContents* new_contents, |
| 266 | WindowOpenDisposition disposition, |
bokan | 107a47f | 2015-02-03 23:23:39 | [diff] [blame] | 267 | const gfx::Rect& initial_rect, |
[email protected] | a290409 | 2013-10-15 04:53:59 | [diff] [blame] | 268 | bool user_gesture, |
| 269 | bool* was_blocked) { |
bokan | 107a47f | 2015-02-03 23:23:39 | [diff] [blame] | 270 | CreateShell(new_contents, AdjustWindowSize(initial_rect.size())); |
lukasza | 381b049 | 2016-03-10 16:48:43 | [diff] [blame] | 271 | if (switches::IsRunLayoutTestSwitchPresent()) |
lukasza | 8e550a0 | 2016-04-18 18:34:17 | [diff] [blame] | 272 | SecondaryTestWindowObserver::CreateForWebContents(new_contents); |
[email protected] | a290409 | 2013-10-15 04:53:59 | [diff] [blame] | 273 | } |
| 274 | |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 275 | void Shell::GoBackOrForward(int offset) { |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 276 | web_contents_->GetController().GoToOffset(offset); |
[email protected] | fc2b46b | 2014-05-03 16:33:45 | [diff] [blame] | 277 | web_contents_->Focus(); |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | void Shell::Reload() { |
toyoshim | 6142d96f | 2016-12-19 09:07:25 | [diff] [blame] | 281 | web_contents_->GetController().Reload(ReloadType::NORMAL, false); |
[email protected] | fc2b46b | 2014-05-03 16:33:45 | [diff] [blame] | 282 | web_contents_->Focus(); |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 283 | } |
| 284 | |
toyoshim | e5aaf6a | 2016-05-18 08:07:48 | [diff] [blame] | 285 | void Shell::ReloadBypassingCache() { |
toyoshim | 6142d96f | 2016-12-19 09:07:25 | [diff] [blame] | 286 | web_contents_->GetController().Reload(ReloadType::BYPASSING_CACHE, false); |
toyoshim | e5aaf6a | 2016-05-18 08:07:48 | [diff] [blame] | 287 | web_contents_->Focus(); |
| 288 | } |
| 289 | |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 290 | void Shell::Stop() { |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 291 | web_contents_->Stop(); |
[email protected] | fc2b46b | 2014-05-03 16:33:45 | [diff] [blame] | 292 | web_contents_->Focus(); |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 293 | } |
| 294 | |
[email protected] | e3b10d1 | 2014-03-28 16:06:09 | [diff] [blame] | 295 | void Shell::UpdateNavigationControls(bool to_different_document) { |
[email protected] | 0b659b3 | 2012-03-26 21:29:32 | [diff] [blame] | 296 | int current_index = web_contents_->GetController().GetCurrentEntryIndex(); |
| 297 | int max_index = web_contents_->GetController().GetEntryCount() - 1; |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 298 | |
| 299 | PlatformEnableUIControl(BACK_BUTTON, current_index > 0); |
| 300 | PlatformEnableUIControl(FORWARD_BUTTON, current_index < max_index); |
[email protected] | e3b10d1 | 2014-03-28 16:06:09 | [diff] [blame] | 301 | PlatformEnableUIControl(STOP_BUTTON, |
| 302 | to_different_document && web_contents_->IsLoading()); |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 303 | } |
| 304 | |
[email protected] | 7c17b699 | 2012-08-09 16:16:30 | [diff] [blame] | 305 | void Shell::ShowDevTools() { |
mohsen | 6eb57fb | 2016-07-22 03:14:08 | [diff] [blame] | 306 | if (!devtools_frontend_) { |
| 307 | devtools_frontend_ = ShellDevToolsFrontend::Show(web_contents()); |
| 308 | devtools_observer_.reset(new DevToolsWebContentsObserver( |
| 309 | this, devtools_frontend_->frontend_shell()->web_contents())); |
| 310 | } |
[email protected] | 3142e5d | 2014-02-07 00:54:46 | [diff] [blame] | 311 | |
mohsen | 6eb57fb | 2016-07-22 03:14:08 | [diff] [blame] | 312 | devtools_frontend_->Activate(); |
| 313 | devtools_frontend_->Focus(); |
[email protected] | 7c17b699 | 2012-08-09 16:16:30 | [diff] [blame] | 314 | } |
| 315 | |
[email protected] | 001841c9 | 2012-12-11 17:00:13 | [diff] [blame] | 316 | void Shell::CloseDevTools() { |
[email protected] | 0773e0c | 2013-01-25 15:57:57 | [diff] [blame] | 317 | if (!devtools_frontend_) |
[email protected] | 001841c9 | 2012-12-11 17:00:13 | [diff] [blame] | 318 | return; |
[email protected] | 7fff43e | 2013-05-21 20:21:10 | [diff] [blame] | 319 | devtools_observer_.reset(); |
[email protected] | 0773e0c | 2013-01-25 15:57:57 | [diff] [blame] | 320 | devtools_frontend_->Close(); |
Ivan Kotenkov | 2c0d2bb3 | 2017-11-01 15:41:28 | [diff] [blame] | 321 | devtools_frontend_ = nullptr; |
[email protected] | 001841c9 | 2012-12-11 17:00:13 | [diff] [blame] | 322 | } |
| 323 | |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 324 | gfx::NativeView Shell::GetContentView() { |
[email protected] | 59383c78 | 2013-04-17 16:43:27 | [diff] [blame] | 325 | if (!web_contents_) |
Ivan Kotenkov | 2c0d2bb3 | 2017-11-01 15:41:28 | [diff] [blame] | 326 | return nullptr; |
[email protected] | fc2b46b | 2014-05-03 16:33:45 | [diff] [blame] | 327 | return web_contents_->GetNativeView(); |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 328 | } |
| 329 | |
alexmos | 5a98a05 | 2016-01-06 00:15:02 | [diff] [blame] | 330 | WebContents* Shell::OpenURLFromTab(WebContents* source, |
| 331 | const OpenURLParams& params) { |
lukasza | 0413015 | 2016-10-21 20:26:32 | [diff] [blame] | 332 | WebContents* target = nullptr; |
| 333 | switch (params.disposition) { |
| 334 | case WindowOpenDisposition::CURRENT_TAB: |
| 335 | target = source; |
| 336 | break; |
| 337 | |
| 338 | // Normally, the difference between NEW_POPUP and NEW_WINDOW is that a popup |
| 339 | // should have no toolbar, no status bar, no menu bar, no scrollbars and be |
| 340 | // not resizable. For simplicity and to enable new testing scenarios in |
| 341 | // content shell and layout tests, popups don't get special treatment below |
| 342 | // (i.e. they will have a toolbar and other things described here). |
| 343 | case WindowOpenDisposition::NEW_POPUP: |
lukasza | be2f0da | 2017-04-25 00:43:00 | [diff] [blame] | 344 | case WindowOpenDisposition::NEW_WINDOW: |
| 345 | // content_shell doesn't really support tabs, but some layout tests use |
| 346 | // middle click (which translates into kNavigationPolicyNewBackgroundTab), |
| 347 | // so we treat the cases below just like a NEW_WINDOW disposition. |
| 348 | case WindowOpenDisposition::NEW_BACKGROUND_TAB: |
| 349 | case WindowOpenDisposition::NEW_FOREGROUND_TAB: { |
lukasza | 0413015 | 2016-10-21 20:26:32 | [diff] [blame] | 350 | Shell* new_window = |
| 351 | Shell::CreateNewWindow(source->GetBrowserContext(), |
| 352 | GURL(), // Don't load anything just yet. |
| 353 | params.source_site_instance, |
| 354 | gfx::Size()); // Use default size. |
| 355 | target = new_window->web_contents(); |
| 356 | if (switches::IsRunLayoutTestSwitchPresent()) |
| 357 | SecondaryTestWindowObserver::CreateForWebContents(target); |
| 358 | break; |
| 359 | } |
| 360 | |
| 361 | // No tabs in content_shell: |
| 362 | case WindowOpenDisposition::SINGLETON_TAB: |
lukasza | 0413015 | 2016-10-21 20:26:32 | [diff] [blame] | 363 | // No incognito mode in content_shell: |
| 364 | case WindowOpenDisposition::OFF_THE_RECORD: |
| 365 | // TODO(lukasza): Investigate if some layout tests might need support for |
| 366 | // SAVE_TO_DISK disposition. This would probably require that |
| 367 | // BlinkTestController always sets up and cleans up a temporary directory |
| 368 | // as the default downloads destinations for the duration of a test. |
| 369 | case WindowOpenDisposition::SAVE_TO_DISK: |
| 370 | // Ignoring requests with disposition == IGNORE_ACTION... |
| 371 | case WindowOpenDisposition::IGNORE_ACTION: |
| 372 | default: |
| 373 | return nullptr; |
| 374 | } |
alexmos | 5a98a05 | 2016-01-06 00:15:02 | [diff] [blame] | 375 | |
| 376 | NavigationController::LoadURLParams load_url_params(params.url); |
| 377 | load_url_params.source_site_instance = params.source_site_instance; |
| 378 | load_url_params.transition_type = params.transition; |
| 379 | load_url_params.frame_tree_node_id = params.frame_tree_node_id; |
| 380 | load_url_params.referrer = params.referrer; |
| 381 | load_url_params.redirect_chain = params.redirect_chain; |
| 382 | load_url_params.extra_headers = params.extra_headers; |
| 383 | load_url_params.is_renderer_initiated = params.is_renderer_initiated; |
alexmos | 5a98a05 | 2016-01-06 00:15:02 | [diff] [blame] | 384 | load_url_params.should_replace_current_entry = |
| 385 | params.should_replace_current_entry; |
| 386 | |
lukasza | 477a5a2 | 2016-06-16 18:28:43 | [diff] [blame] | 387 | if (params.uses_post) { |
| 388 | load_url_params.load_type = NavigationController::LOAD_TYPE_HTTP_POST; |
| 389 | load_url_params.post_data = params.post_data; |
alexmos | 5a98a05 | 2016-01-06 00:15:02 | [diff] [blame] | 390 | } |
| 391 | |
lukasza | 0413015 | 2016-10-21 20:26:32 | [diff] [blame] | 392 | target->GetController().LoadURLWithParams(load_url_params); |
| 393 | return target; |
alexmos | 5a98a05 | 2016-01-06 00:15:02 | [diff] [blame] | 394 | } |
| 395 | |
[email protected] | e3b10d1 | 2014-03-28 16:06:09 | [diff] [blame] | 396 | void Shell::LoadingStateChanged(WebContents* source, |
| 397 | bool to_different_document) { |
| 398 | UpdateNavigationControls(to_different_document); |
[email protected] | 15aea41 | 2012-01-19 03:18:50 | [diff] [blame] | 399 | PlatformSetIsLoading(source->IsLoading()); |
[email protected] | e99ca511 | 2011-09-26 17:22:54 | [diff] [blame] | 400 | } |
| 401 | |
mlamouri | 7a78d6fd | 2015-01-17 13:23:53 | [diff] [blame] | 402 | void Shell::EnterFullscreenModeForTab(WebContents* web_contents, |
| 403 | const GURL& origin) { |
| 404 | ToggleFullscreenModeForTab(web_contents, true); |
| 405 | } |
| 406 | |
| 407 | void Shell::ExitFullscreenModeForTab(WebContents* web_contents) { |
| 408 | ToggleFullscreenModeForTab(web_contents, false); |
| 409 | } |
| 410 | |
[email protected] | 99c014c | 2012-11-27 12:03:42 | [diff] [blame] | 411 | void Shell::ToggleFullscreenModeForTab(WebContents* web_contents, |
| 412 | bool enter_fullscreen) { |
| 413 | #if defined(OS_ANDROID) |
| 414 | PlatformToggleFullscreenModeForTab(web_contents, enter_fullscreen); |
| 415 | #endif |
lukasza | 381b049 | 2016-03-10 16:48:43 | [diff] [blame] | 416 | if (!switches::IsRunLayoutTestSwitchPresent()) |
[email protected] | 99c014c | 2012-11-27 12:03:42 | [diff] [blame] | 417 | return; |
| 418 | if (is_fullscreen_ != enter_fullscreen) { |
| 419 | is_fullscreen_ = enter_fullscreen; |
avi | f9ab5d94 | 2015-10-15 14:05:44 | [diff] [blame] | 420 | web_contents->GetRenderViewHost()->GetWidget()->WasResized(); |
[email protected] | 99c014c | 2012-11-27 12:03:42 | [diff] [blame] | 421 | } |
| 422 | } |
| 423 | |
| 424 | bool Shell::IsFullscreenForTabOrPending(const WebContents* web_contents) const { |
| 425 | #if defined(OS_ANDROID) |
| 426 | return PlatformIsFullscreenForTabOrPending(web_contents); |
| 427 | #else |
| 428 | return is_fullscreen_; |
| 429 | #endif |
| 430 | } |
| 431 | |
mikhail.pozdnyakov | c0e251b | 2015-04-15 06:51:12 | [diff] [blame] | 432 | blink::WebDisplayMode Shell::GetDisplayMode( |
| 433 | const WebContents* web_contents) const { |
| 434 | // TODO : should return blink::WebDisplayModeFullscreen wherever user puts |
| 435 | // a browser window into fullscreen (not only in case of renderer-initiated |
| 436 | // fullscreen mode): crbug.com/476874. |
Blink Reformat | 1c4d759e | 2017-04-09 16:34:54 | [diff] [blame] | 437 | return IsFullscreenForTabOrPending(web_contents) |
| 438 | ? blink::kWebDisplayModeFullscreen |
| 439 | : blink::kWebDisplayModeBrowser; |
mikhail.pozdnyakov | c0e251b | 2015-04-15 06:51:12 | [diff] [blame] | 440 | } |
| 441 | |
[email protected] | f7843900 | 2012-11-28 14:45:59 | [diff] [blame] | 442 | void Shell::RequestToLockMouse(WebContents* web_contents, |
| 443 | bool user_gesture, |
| 444 | bool last_unlocked_by_target) { |
| 445 | web_contents->GotResponseToLockMouseRequest(true); |
| 446 | } |
| 447 | |
[email protected] | 9e00e635 | 2012-07-30 17:05:18 | [diff] [blame] | 448 | void Shell::CloseContents(WebContents* source) { |
| 449 | Close(); |
| 450 | } |
| 451 | |
[email protected] | 06731026 | 2012-11-22 14:30:41 | [diff] [blame] | 452 | bool Shell::CanOverscrollContent() const { |
| 453 | #if defined(USE_AURA) |
| 454 | return true; |
| 455 | #else |
| 456 | return false; |
| 457 | #endif |
| 458 | } |
| 459 | |
[email protected] | 3bbacc5b | 2012-04-17 17:46:15 | [diff] [blame] | 460 | void Shell::DidNavigateMainFramePostCommit(WebContents* web_contents) { |
[email protected] | 4e3c752 | 2013-08-13 11:53:18 | [diff] [blame] | 461 | PlatformSetAddressBarURL(web_contents->GetLastCommittedURL()); |
[email protected] | e99ca511 | 2011-09-26 17:22:54 | [diff] [blame] | 462 | } |
| 463 | |
mathiash | 72a5e46 | 2014-11-19 08:18:50 | [diff] [blame] | 464 | JavaScriptDialogManager* Shell::GetJavaScriptDialogManager( |
| 465 | WebContents* source) { |
mkwst | 6efe7f2e6 | 2014-10-08 15:09:01 | [diff] [blame] | 466 | if (!dialog_manager_) { |
lukasza | 381b049 | 2016-03-10 16:48:43 | [diff] [blame] | 467 | dialog_manager_.reset(switches::IsRunLayoutTestSwitchPresent() |
| 468 | ? new LayoutTestJavaScriptDialogManager |
| 469 | : new ShellJavaScriptDialogManager); |
mkwst | 6efe7f2e6 | 2014-10-08 15:09:01 | [diff] [blame] | 470 | } |
[email protected] | 71a88bb | 2013-02-01 22:05:15 | [diff] [blame] | 471 | return dialog_manager_.get(); |
[email protected] | f221002 | 2012-03-29 00:36:08 | [diff] [blame] | 472 | } |
| 473 | |
dcheng | 6003e0b | 2016-04-09 18:42:34 | [diff] [blame] | 474 | std::unique_ptr<BluetoothChooser> Shell::RunBluetoothChooser( |
jyasskin | 93649a5 | 2016-02-17 19:57:02 | [diff] [blame] | 475 | RenderFrameHost* frame, |
| 476 | const BluetoothChooser::EventHandler& event_handler) { |
Lukasz Anforowicz | f227b491 | 2017-12-22 23:08:59 | [diff] [blame] | 477 | BlinkTestController* blink_test_controller = BlinkTestController::Get(); |
| 478 | if (blink_test_controller && switches::IsRunLayoutTestSwitchPresent()) |
| 479 | return blink_test_controller->RunBluetoothChooser(frame, event_handler); |
jyasskin | 8057c00 | 2015-09-10 19:09:53 | [diff] [blame] | 480 | return nullptr; |
| 481 | } |
| 482 | |
avi | a90ae4e | 2016-11-11 20:49:33 | [diff] [blame] | 483 | bool Shell::DidAddMessageToConsole(WebContents* source, |
| 484 | int32_t level, |
| 485 | const base::string16& message, |
| 486 | int32_t line_no, |
| 487 | const base::string16& source_id) { |
lukasza | 381b049 | 2016-03-10 16:48:43 | [diff] [blame] | 488 | return switches::IsRunLayoutTestSwitchPresent(); |
[email protected] | efb5f57 | 2012-01-29 10:57:33 | [diff] [blame] | 489 | } |
| 490 | |
Avi Drissman | 8920def | 2018-01-31 19:53:36 | [diff] [blame] | 491 | void Shell::RendererUnresponsive(WebContents* source, |
Avi Drissman | 1572e8c3c | 2018-02-02 19:06:36 | [diff] [blame^] | 492 | RenderWidgetHost* render_widget_host) { |
Lukasz Anforowicz | f227b491 | 2017-12-22 23:08:59 | [diff] [blame] | 493 | BlinkTestController* blink_test_controller = BlinkTestController::Get(); |
| 494 | if (blink_test_controller && switches::IsRunLayoutTestSwitchPresent()) |
| 495 | blink_test_controller->RendererUnresponsive(); |
[email protected] | 5bf68f2 | 2012-08-31 07:38:10 | [diff] [blame] | 496 | } |
| 497 | |
[email protected] | 233567d | 2013-02-27 20:22:02 | [diff] [blame] | 498 | void Shell::ActivateContents(WebContents* contents) { |
avi | f9ab5d94 | 2015-10-15 14:05:44 | [diff] [blame] | 499 | contents->GetRenderViewHost()->GetWidget()->Focus(); |
[email protected] | 233567d | 2013-02-27 20:22:02 | [diff] [blame] | 500 | } |
| 501 | |
carlosk | d9d9794 | 2017-02-16 08:58:09 | [diff] [blame] | 502 | bool Shell::ShouldAllowRunningInsecureContent( |
| 503 | content::WebContents* web_contents, |
| 504 | bool allowed_per_prefs, |
| 505 | const url::Origin& origin, |
| 506 | const GURL& resource_url) { |
| 507 | bool allowed_by_test = false; |
Lukasz Anforowicz | f227b491 | 2017-12-22 23:08:59 | [diff] [blame] | 508 | BlinkTestController* blink_test_controller = BlinkTestController::Get(); |
| 509 | if (blink_test_controller && |
| 510 | base::CommandLine::ForCurrentProcess()->HasSwitch( |
carlosk | d9d9794 | 2017-02-16 08:58:09 | [diff] [blame] | 511 | switches::kRunLayoutTest)) { |
| 512 | const base::DictionaryValue& test_flags = |
Lukasz Anforowicz | f227b491 | 2017-12-22 23:08:59 | [diff] [blame] | 513 | blink_test_controller->accumulated_layout_test_runtime_flags_changes(); |
carlosk | d9d9794 | 2017-02-16 08:58:09 | [diff] [blame] | 514 | test_flags.GetBoolean("running_insecure_content_allowed", &allowed_by_test); |
| 515 | } |
| 516 | |
| 517 | return allowed_per_prefs || allowed_by_test; |
| 518 | } |
| 519 | |
pdr | cab84ee | 2015-03-13 21:47:04 | [diff] [blame] | 520 | gfx::Size Shell::GetShellDefaultSize() { |
| 521 | static gfx::Size default_shell_size; |
| 522 | if (!default_shell_size.IsEmpty()) |
| 523 | return default_shell_size; |
| 524 | base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); |
| 525 | if (command_line->HasSwitch(switches::kContentShellHostWindowSize)) { |
| 526 | const std::string size_str = command_line->GetSwitchValueASCII( |
| 527 | switches::kContentShellHostWindowSize); |
| 528 | int width, height; |
| 529 | CHECK_EQ(2, sscanf(size_str.c_str(), "%dx%d", &width, &height)); |
| 530 | default_shell_size = gfx::Size(width, height); |
| 531 | } else { |
| 532 | default_shell_size = gfx::Size( |
| 533 | kDefaultTestWindowWidthDip, kDefaultTestWindowHeightDip); |
| 534 | } |
| 535 | return default_shell_size; |
| 536 | } |
| 537 | |
Avi Drissman | 9300221 | 2017-09-27 03:20:52 | [diff] [blame] | 538 | void Shell::TitleWasSet(NavigationEntry* entry) { |
[email protected] | 1ef02d24 | 2013-10-07 16:18:53 | [diff] [blame] | 539 | if (entry) |
| 540 | PlatformSetTitle(entry->GetTitle()); |
[email protected] | aecc085b | 2012-06-01 18:15:53 | [diff] [blame] | 541 | } |
| 542 | |
[email protected] | 7fff43e | 2013-05-21 20:21:10 | [diff] [blame] | 543 | void Shell::OnDevToolsWebContentsDestroyed() { |
| 544 | devtools_observer_.reset(); |
Ivan Kotenkov | 2c0d2bb3 | 2017-11-01 15:41:28 | [diff] [blame] | 545 | devtools_frontend_ = nullptr; |
[email protected] | 7fff43e | 2013-05-21 20:21:10 | [diff] [blame] | 546 | } |
| 547 | |
[email protected] | 9fbd3f86 | 2011-09-20 23:31:34 | [diff] [blame] | 548 | } // namespace content |