content/shell/browser/shell.cc

   1 // Copyright 2013 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 "content/shell/browser/shell.h"
   6
   7 #include "base/auto_reset.h"
   8 #include "base/command_line.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/path_service.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/stringprintf.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "content/public/browser/devtools_agent_host.h"
  16 #include "content/public/browser/navigation_controller.h"
  17 #include "content/public/browser/navigation_entry.h"
  18 #include "content/public/browser/render_view_host.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "content/public/browser/web_contents_observer.h"
  21 #include "content/public/common/renderer_preferences.h"
  22 #include "content/shell/browser/notify_done_forwarder.h"
  23 #include "content/shell/browser/shell_browser_main_parts.h"
  24 #include "content/shell/browser/shell_content_browser_client.h"
  25 #include "content/shell/browser/shell_devtools_frontend.h"
  26 #include "content/shell/browser/shell_javascript_dialog_manager.h"
  27 #include "content/shell/browser/webkit_test_controller.h"
  28 #include "content/shell/common/shell_messages.h"
  29 #include "content/shell/common/shell_switches.h"
  30
  31 namespace content {
  32
  33 const int Shell::kDefaultTestWindowWidthDip = 800;
  34 const int Shell::kDefaultTestWindowHeightDip = 600;
  35
  36 std::vector<Shell*> Shell::windows_;
  37 base::Callback<void(Shell*)> Shell::shell_created_callback_;
  38
  39 bool Shell::quit_message_loop_ = true;
  40
  41 class Shell::DevToolsWebContentsObserver : public WebContentsObserver {
  42  public:
  43   DevToolsWebContentsObserver(Shell* shell, WebContents* web_contents)
  44       : WebContentsObserver(web_contents),
  45         shell_(shell) {
  46   }
  47
  48   // WebContentsObserver
  49   virtual void WebContentsDestroyed() OVERRIDE {
  50     shell_->OnDevToolsWebContentsDestroyed();
  51   }
  52
  53  private:
  54   Shell* shell_;
  55
  56   DISALLOW_COPY_AND_ASSIGN(DevToolsWebContentsObserver);
  57 };
  58
  59 Shell::Shell(WebContents* web_contents)
  60     : WebContentsObserver(web_contents),
  61       devtools_frontend_(NULL),
  62       is_fullscreen_(false),
  63       window_(NULL),
  64       url_edit_view_(NULL),
  65       headless_(false) {
  66   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
  67   if (command_line.HasSwitch(switches::kDumpRenderTree))
  68     headless_ = true;
  69   windows_.push_back(this);
  70
  71   if (!shell_created_callback_.is_null()) {
  72     shell_created_callback_.Run(this);
  73     shell_created_callback_.Reset();
  74   }
  75 }
  76
  77 Shell::~Shell() {
  78   PlatformCleanUp();
  79
  80   for (size_t i = 0; i < windows_.size(); ++i) {
  81     if (windows_[i] == this) {
  82       windows_.erase(windows_.begin() + i);
  83       break;
  84     }
  85   }
  86
  87   if (windows_.empty() && quit_message_loop_) {
  88     if (headless_)
  89       PlatformExit();
  90     base::MessageLoop::current()->PostTask(FROM_HERE,
  91                                            base::MessageLoop::QuitClosure());
  92   }
  93 }
  94
  95 Shell* Shell::CreateShell(WebContents* web_contents,
  96                           const gfx::Size& initial_size) {
  97   Shell* shell = new Shell(web_contents);
  98   shell->PlatformCreateWindow(initial_size.width(), initial_size.height());
  99
 100   shell->web_contents_.reset(web_contents);
 101   web_contents->SetDelegate(shell);
 102
 103   shell->PlatformSetContents();
 104
 105   shell->PlatformResizeSubViews();
 106
 107   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree)) {
 108     web_contents->GetMutableRendererPrefs()->use_custom_colors = false;
 109     web_contents->GetRenderViewHost()->SyncRendererPrefs();
 110   }
 111
 112   return shell;
 113 }
 114
 115 void Shell::CloseAllWindows() {
 116   base::AutoReset<bool> auto_reset(&quit_message_loop_, false);
 117   DevToolsAgentHost::DetachAllClients();
 118   std::vector<Shell*> open_windows(windows_);
 119   for (size_t i = 0; i < open_windows.size(); ++i)
 120     open_windows[i]->Close();
 121   PlatformExit();
 122   base::MessageLoop::current()->RunUntilIdle();
 123 }
 124
 125 void Shell::SetShellCreatedCallback(
 126     base::Callback<void(Shell*)> shell_created_callback) {
 127   DCHECK(shell_created_callback_.is_null());
 128   shell_created_callback_ = shell_created_callback;
 129 }
 130
 131 Shell* Shell::FromRenderViewHost(RenderViewHost* rvh) {
 132   for (size_t i = 0; i < windows_.size(); ++i) {
 133     if (windows_[i]->web_contents() &&
 134         windows_[i]->web_contents()->GetRenderViewHost() == rvh) {
 135       return windows_[i];
 136     }
 137   }
 138   return NULL;
 139 }
 140
 141 // static
 142 void Shell::Initialize() {
 143   PlatformInitialize(
 144       gfx::Size(kDefaultTestWindowWidthDip, kDefaultTestWindowHeightDip));
 145 }
 146
 147 gfx::Size Shell::AdjustWindowSize(const gfx::Size& initial_size) {
 148   if (!initial_size.IsEmpty())
 149     return initial_size;
 150   return gfx::Size(kDefaultTestWindowWidthDip, kDefaultTestWindowHeightDip);
 151 }
 152
 153 Shell* Shell::CreateNewWindow(BrowserContext* browser_context,
 154                               const GURL& url,
 155                               SiteInstance* site_instance,
 156                               int routing_id,
 157                               const gfx::Size& initial_size) {
 158   WebContents::CreateParams create_params(browser_context, site_instance);
 159   create_params.routing_id = routing_id;
 160   create_params.initial_size = AdjustWindowSize(initial_size);
 161   WebContents* web_contents = WebContents::Create(create_params);
 162   Shell* shell = CreateShell(web_contents, create_params.initial_size);
 163   if (!url.is_empty())
 164     shell->LoadURL(url);
 165   return shell;
 166 }
 167
 168 void Shell::LoadURL(const GURL& url) {
 169   LoadURLForFrame(url, std::string());
 170 }
 171
 172 void Shell::LoadURLForFrame(const GURL& url, const std::string& frame_name) {
 173   NavigationController::LoadURLParams params(url);
 174   params.transition_type = PageTransitionFromInt(
 175       PAGE_TRANSITION_TYPED | PAGE_TRANSITION_FROM_ADDRESS_BAR);
 176   params.frame_name = frame_name;
 177   web_contents_->GetController().LoadURLWithParams(params);
 178   web_contents_->Focus();
 179 }
 180
 181 void Shell::LoadDataWithBaseURL(const GURL& url, const std::string& data,
 182     const GURL& base_url) {
 183   const GURL data_url = GURL("data:text/html;charset=utf-8," + data);
 184   NavigationController::LoadURLParams params(data_url);
 185   params.load_type = NavigationController::LOAD_TYPE_DATA;
 186   params.base_url_for_data_url = base_url;
 187   params.virtual_url_for_data_url = url;
 188   params.override_user_agent = NavigationController::UA_OVERRIDE_FALSE;
 189   web_contents_->GetController().LoadURLWithParams(params);
 190   web_contents_->Focus();
 191 }
 192
 193 void Shell::AddNewContents(WebContents* source,
 194                            WebContents* new_contents,
 195                            WindowOpenDisposition disposition,
 196                            const gfx::Rect& initial_pos,
 197                            bool user_gesture,
 198                            bool* was_blocked) {
 199   CreateShell(new_contents, AdjustWindowSize(initial_pos.size()));
 200   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 201     NotifyDoneForwarder::CreateForWebContents(new_contents);
 202 }
 203
 204 void Shell::GoBackOrForward(int offset) {
 205   web_contents_->GetController().GoToOffset(offset);
 206   web_contents_->Focus();
 207 }
 208
 209 void Shell::Reload() {
 210   web_contents_->GetController().Reload(false);
 211   web_contents_->Focus();
 212 }
 213
 214 void Shell::Stop() {
 215   web_contents_->Stop();
 216   web_contents_->Focus();
 217 }
 218
 219 void Shell::UpdateNavigationControls(bool to_different_document) {
 220   int current_index = web_contents_->GetController().GetCurrentEntryIndex();
 221   int max_index = web_contents_->GetController().GetEntryCount() - 1;
 222
 223   PlatformEnableUIControl(BACK_BUTTON, current_index > 0);
 224   PlatformEnableUIControl(FORWARD_BUTTON, current_index < max_index);
 225   PlatformEnableUIControl(STOP_BUTTON,
 226       to_different_document && web_contents_->IsLoading());
 227 }
 228
 229 void Shell::ShowDevTools() {
 230   InnerShowDevTools("", "");
 231 }
 232
 233 void Shell::ShowDevToolsForElementAt(int x, int y) {
 234   InnerShowDevTools("", "");
 235   devtools_frontend_->InspectElementAt(x, y);
 236 }
 237
 238 void Shell::ShowDevToolsForTest(const std::string& settings,
 239                                 const std::string& frontend_url) {
 240   InnerShowDevTools(settings, frontend_url);
 241 }
 242
 243 void Shell::CloseDevTools() {
 244   if (!devtools_frontend_)
 245     return;
 246   devtools_observer_.reset();
 247   devtools_frontend_->Close();
 248   devtools_frontend_ = NULL;
 249 }
 250
 251 gfx::NativeView Shell::GetContentView() {
 252   if (!web_contents_)
 253     return NULL;
 254   return web_contents_->GetNativeView();
 255 }
 256
 257 WebContents* Shell::OpenURLFromTab(WebContents* source,
 258                                    const OpenURLParams& params) {
 259   // CURRENT_TAB is the only one we implement for now.
 260   if (params.disposition != CURRENT_TAB)
 261       return NULL;
 262   NavigationController::LoadURLParams load_url_params(params.url);
 263   load_url_params.referrer = params.referrer;
 264   load_url_params.frame_tree_node_id = params.frame_tree_node_id;
 265   load_url_params.transition_type = params.transition;
 266   load_url_params.extra_headers = params.extra_headers;
 267   load_url_params.should_replace_current_entry =
 268       params.should_replace_current_entry;
 269
 270   if (params.transferred_global_request_id != GlobalRequestID()) {
 271     load_url_params.is_renderer_initiated = params.is_renderer_initiated;
 272     load_url_params.transferred_global_request_id =
 273         params.transferred_global_request_id;
 274   } else if (params.is_renderer_initiated) {
 275     load_url_params.is_renderer_initiated = true;
 276   }
 277
 278   source->GetController().LoadURLWithParams(load_url_params);
 279   return source;
 280 }
 281
 282 void Shell::LoadingStateChanged(WebContents* source,
 283     bool to_different_document) {
 284   UpdateNavigationControls(to_different_document);
 285   PlatformSetIsLoading(source->IsLoading());
 286 }
 287
 288 void Shell::ToggleFullscreenModeForTab(WebContents* web_contents,
 289                                        bool enter_fullscreen) {
 290 #if defined(OS_ANDROID)
 291   PlatformToggleFullscreenModeForTab(web_contents, enter_fullscreen);
 292 #endif
 293   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 294     return;
 295   if (is_fullscreen_ != enter_fullscreen) {
 296     is_fullscreen_ = enter_fullscreen;
 297     web_contents->GetRenderViewHost()->WasResized();
 298   }
 299 }
 300
 301 bool Shell::IsFullscreenForTabOrPending(const WebContents* web_contents) const {
 302 #if defined(OS_ANDROID)
 303   return PlatformIsFullscreenForTabOrPending(web_contents);
 304 #else
 305   return is_fullscreen_;
 306 #endif
 307 }
 308
 309 void Shell::RequestToLockMouse(WebContents* web_contents,
 310                                bool user_gesture,
 311                                bool last_unlocked_by_target) {
 312   web_contents->GotResponseToLockMouseRequest(true);
 313 }
 314
 315 void Shell::CloseContents(WebContents* source) {
 316   Close();
 317 }
 318
 319 bool Shell::CanOverscrollContent() const {
 320 #if defined(USE_AURA)
 321   return true;
 322 #else
 323   return false;
 324 #endif
 325 }
 326
 327 void Shell::DidNavigateMainFramePostCommit(WebContents* web_contents) {
 328   PlatformSetAddressBarURL(web_contents->GetLastCommittedURL());
 329 }
 330
 331 JavaScriptDialogManager* Shell::GetJavaScriptDialogManager() {
 332   if (!dialog_manager_)
 333     dialog_manager_.reset(new ShellJavaScriptDialogManager());
 334   return dialog_manager_.get();
 335 }
 336
 337 bool Shell::AddMessageToConsole(WebContents* source,
 338                                 int32 level,
 339                                 const base::string16& message,
 340                                 int32 line_no,
 341                                 const base::string16& source_id) {
 342   return CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree);
 343 }
 344
 345 void Shell::RendererUnresponsive(WebContents* source) {
 346   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 347     return;
 348   WebKitTestController::Get()->RendererUnresponsive();
 349 }
 350
 351 void Shell::ActivateContents(WebContents* contents) {
 352   contents->GetRenderViewHost()->Focus();
 353 }
 354
 355 void Shell::DeactivateContents(WebContents* contents) {
 356   contents->GetRenderViewHost()->Blur();
 357 }
 358
 359 void Shell::WorkerCrashed(WebContents* source) {
 360   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 361     return;
 362   WebKitTestController::Get()->WorkerCrashed();
 363 }
 364
 365 bool Shell::HandleContextMenu(const content::ContextMenuParams& params) {
 366   return PlatformHandleContextMenu(params);
 367 }
 368
 369 void Shell::WebContentsFocused(WebContents* contents) {
 370 #if defined(TOOLKIT_VIEWS)
 371   PlatformWebContentsFocused(contents);
 372 #endif
 373 }
 374
 375 void Shell::TitleWasSet(NavigationEntry* entry, bool explicit_set) {
 376   if (entry)
 377     PlatformSetTitle(entry->GetTitle());
 378 }
 379
 380 void Shell::InnerShowDevTools(const std::string& settings,
 381                               const std::string& frontend_url) {
 382   if (!devtools_frontend_) {
 383     devtools_frontend_ = ShellDevToolsFrontend::Show(
 384         web_contents(), settings, frontend_url);
 385     devtools_observer_.reset(new DevToolsWebContentsObserver(
 386         this, devtools_frontend_->frontend_shell()->web_contents()));
 387   }
 388
 389   devtools_frontend_->Activate();
 390   devtools_frontend_->Focus();
 391 }
 392
 393 void Shell::OnDevToolsWebContentsDestroyed() {
 394   devtools_observer_.reset();
 395   devtools_frontend_ = NULL;
 396 }
 397
 398 }  // namespace content