content/shell/browser/shell_views.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/command_line.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "content/public/browser/context_factory.h"
  10 #include "content/public/browser/render_widget_host_view.h"
  11 #include "content/public/browser/web_contents.h"
  12 #include "content/public/common/context_menu_params.h"
  13 #include "content/shell/browser/shell_platform_data_aura.h"
  14 #include "ui/aura/client/screen_position_client.h"
  15 #include "ui/aura/env.h"
  16 #include "ui/aura/window.h"
  17 #include "ui/aura/window_event_dispatcher.h"
  18 #include "ui/base/clipboard/clipboard.h"
  19 #include "ui/base/models/simple_menu_model.h"
  20 #include "ui/base/resource/resource_bundle.h"
  21 #include "ui/events/event.h"
  22 #include "ui/gfx/screen.h"
  23 #include "ui/views/background.h"
  24 #include "ui/views/controls/button/label_button.h"
  25 #include "ui/views/controls/button/menu_button.h"
  26 #include "ui/views/controls/button/menu_button_listener.h"
  27 #include "ui/views/controls/menu/menu_runner.h"
  28 #include "ui/views/controls/textfield/textfield.h"
  29 #include "ui/views/controls/textfield/textfield_controller.h"
  30 #include "ui/views/controls/webview/webview.h"
  31 #include "ui/views/layout/fill_layout.h"
  32 #include "ui/views/layout/grid_layout.h"
  33 #include "ui/views/test/desktop_test_views_delegate.h"
  34 #include "ui/views/view.h"
  35 #include "ui/views/widget/widget.h"
  36 #include "ui/views/widget/widget_delegate.h"
  37
  38 #if defined(OS_CHROMEOS)
  39 #include "chromeos/dbus/dbus_thread_manager.h"
  40 #include "ui/aura/test/test_screen.h"
  41 #include "ui/wm/test/wm_test_helper.h"
  42 #else  // !defined(OS_CHROMEOS)
  43 #include "ui/views/widget/desktop_aura/desktop_screen.h"
  44 #endif
  45
  46 #if defined(OS_WIN)
  47 #include <fcntl.h>
  48 #include <io.h>
  49 #endif
  50
  51 namespace content {
  52
  53 namespace {
  54 // ViewDelegate implementation for aura content shell
  55 class ShellViewsDelegateAura : public views::DesktopTestViewsDelegate {
  56  public:
  57   ShellViewsDelegateAura() : use_transparent_windows_(false) {
  58   }
  59
  60   virtual ~ShellViewsDelegateAura() {
  61   }
  62
  63   void SetUseTransparentWindows(bool transparent) {
  64     use_transparent_windows_ = transparent;
  65   }
  66
  67  private:
  68   bool use_transparent_windows_;
  69
  70   DISALLOW_COPY_AND_ASSIGN(ShellViewsDelegateAura);
  71 };
  72
  73 // Model for the "Debug" menu
  74 class ContextMenuModel : public ui::SimpleMenuModel,
  75                          public ui::SimpleMenuModel::Delegate {
  76  public:
  77   explicit ContextMenuModel(
  78       Shell* shell, const content::ContextMenuParams& params)
  79     : ui::SimpleMenuModel(this),
  80       shell_(shell),
  81       params_(params) {
  82     AddItem(COMMAND_OPEN_DEVTOOLS, base::ASCIIToUTF16("Inspect Element"));
  83   }
  84
  85   // ui::SimpleMenuModel::Delegate:
  86   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE {
  87     return false;
  88   }
  89   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE {
  90     return true;
  91   }
  92   virtual bool GetAcceleratorForCommandId(
  93       int command_id,
  94       ui::Accelerator* accelerator) OVERRIDE { return false; }
  95   virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE {
  96     switch (command_id) {
  97       case COMMAND_OPEN_DEVTOOLS:
  98         shell_->ShowDevToolsForElementAt(params_.x, params_.y);
  99         break;
 100     };
 101   }
 102
 103  private:
 104   enum CommandID {
 105     COMMAND_OPEN_DEVTOOLS
 106   };
 107
 108   Shell* shell_;
 109   content::ContextMenuParams params_;
 110
 111   DISALLOW_COPY_AND_ASSIGN(ContextMenuModel);
 112 };
 113
 114 // Maintain the UI controls and web view for content shell
 115 class ShellWindowDelegateView : public views::WidgetDelegateView,
 116                                 public views::TextfieldController,
 117                                 public views::ButtonListener {
 118  public:
 119   enum UIControl {
 120     BACK_BUTTON,
 121     FORWARD_BUTTON,
 122     STOP_BUTTON
 123   };
 124
 125   ShellWindowDelegateView(Shell* shell)
 126     : shell_(shell),
 127       toolbar_view_(new View),
 128       contents_view_(new View) {
 129   }
 130   virtual ~ShellWindowDelegateView() {}
 131
 132   // Update the state of UI controls
 133   void SetAddressBarURL(const GURL& url) {
 134     url_entry_->SetText(base::ASCIIToUTF16(url.spec()));
 135   }
 136   void SetWebContents(WebContents* web_contents, const gfx::Size& size) {
 137     contents_view_->SetLayoutManager(new views::FillLayout());
 138     web_view_ = new views::WebView(web_contents->GetBrowserContext());
 139     web_view_->SetWebContents(web_contents);
 140     web_view_->SetPreferredSize(size);
 141     web_contents->Focus();
 142     contents_view_->AddChildView(web_view_);
 143     Layout();
 144
 145     // Resize the widget, keeping the same origin.
 146     gfx::Rect bounds = GetWidget()->GetWindowBoundsInScreen();
 147     bounds.set_size(GetWidget()->GetRootView()->GetPreferredSize());
 148     GetWidget()->SetBounds(bounds);
 149
 150     // Resizing a widget on chromeos doesn't automatically resize the root, need
 151     // to explicitly do that.
 152 #if defined(OS_CHROMEOS)
 153     GetWidget()->GetNativeWindow()->GetHost()->SetBounds(bounds);
 154 #endif
 155   }
 156
 157   void SetWindowTitle(const base::string16& title) { title_ = title; }
 158   void EnableUIControl(UIControl control, bool is_enabled) {
 159     if (control == BACK_BUTTON) {
 160       back_button_->SetState(is_enabled ? views::CustomButton::STATE_NORMAL
 161           : views::CustomButton::STATE_DISABLED);
 162     } else if (control == FORWARD_BUTTON) {
 163       forward_button_->SetState(is_enabled ? views::CustomButton::STATE_NORMAL
 164           : views::CustomButton::STATE_DISABLED);
 165     } else if (control == STOP_BUTTON) {
 166       stop_button_->SetState(is_enabled ? views::CustomButton::STATE_NORMAL
 167           : views::CustomButton::STATE_DISABLED);
 168     }
 169   }
 170
 171   void ShowWebViewContextMenu(const content::ContextMenuParams& params) {
 172     gfx::Point screen_point(params.x, params.y);
 173
 174     // Convert from content coordinates to window coordinates.
 175     // This code copied from chrome_web_contents_view_delegate_views.cc
 176     aura::Window* web_contents_window =
 177         shell_->web_contents()->GetNativeView();
 178     aura::Window* root_window = web_contents_window->GetRootWindow();
 179     aura::client::ScreenPositionClient* screen_position_client =
 180         aura::client::GetScreenPositionClient(root_window);
 181     if (screen_position_client) {
 182         screen_position_client->ConvertPointToScreen(web_contents_window,
 183                 &screen_point);
 184     }
 185
 186     context_menu_model_.reset(new ContextMenuModel(shell_, params));
 187     context_menu_runner_.reset(new views::MenuRunner(
 188         context_menu_model_.get(), views::MenuRunner::CONTEXT_MENU));
 189
 190     if (context_menu_runner_->RunMenuAt(web_view_->GetWidget(),
 191                                         NULL,
 192                                         gfx::Rect(screen_point, gfx::Size()),
 193                                         views::MENU_ANCHOR_TOPRIGHT,
 194                                         ui::MENU_SOURCE_NONE) ==
 195         views::MenuRunner::MENU_DELETED) {
 196       return;
 197     }
 198   }
 199
 200   void OnWebContentsFocused(content::WebContents* web_contents) {
 201     if (web_view_->GetWebContents() == web_contents)
 202       web_view_->OnWebContentsFocused(web_contents);
 203   }
 204
 205  private:
 206   // Initialize the UI control contained in shell window
 207   void InitShellWindow() {
 208     set_background(views::Background::CreateStandardPanelBackground());
 209
 210     views::GridLayout* layout = new views::GridLayout(this);
 211     SetLayoutManager(layout);
 212
 213     views::ColumnSet* column_set = layout->AddColumnSet(0);
 214     column_set->AddPaddingColumn(0, 2);
 215     column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
 216                           views::GridLayout::USE_PREF, 0, 0);
 217     column_set->AddPaddingColumn(0, 2);
 218
 219     layout->AddPaddingRow(0, 2);
 220
 221     // Add toolbar buttons and URL text field
 222     {
 223       layout->StartRow(0, 0);
 224       views::GridLayout* toolbar_layout = new views::GridLayout(toolbar_view_);
 225       toolbar_view_->SetLayoutManager(toolbar_layout);
 226
 227       views::ColumnSet* toolbar_column_set =
 228           toolbar_layout->AddColumnSet(0);
 229       // Back button
 230       back_button_ = new views::LabelButton(this, base::ASCIIToUTF16("Back"));
 231       back_button_->SetStyle(views::Button::STYLE_BUTTON);
 232       gfx::Size back_button_size = back_button_->GetPreferredSize();
 233       toolbar_column_set->AddColumn(views::GridLayout::CENTER,
 234                                     views::GridLayout::CENTER, 0,
 235                                     views::GridLayout::FIXED,
 236                                     back_button_size.width(),
 237                                     back_button_size.width() / 2);
 238       // Forward button
 239       forward_button_ =
 240           new views::LabelButton(this, base::ASCIIToUTF16("Forward"));
 241       forward_button_->SetStyle(views::Button::STYLE_BUTTON);
 242       gfx::Size forward_button_size = forward_button_->GetPreferredSize();
 243       toolbar_column_set->AddColumn(views::GridLayout::CENTER,
 244                                     views::GridLayout::CENTER, 0,
 245                                     views::GridLayout::FIXED,
 246                                     forward_button_size.width(),
 247                                     forward_button_size.width() / 2);
 248       // Refresh button
 249       refresh_button_ =
 250           new views::LabelButton(this, base::ASCIIToUTF16("Refresh"));
 251       refresh_button_->SetStyle(views::Button::STYLE_BUTTON);
 252       gfx::Size refresh_button_size = refresh_button_->GetPreferredSize();
 253       toolbar_column_set->AddColumn(views::GridLayout::CENTER,
 254                                     views::GridLayout::CENTER, 0,
 255                                     views::GridLayout::FIXED,
 256                                     refresh_button_size.width(),
 257                                     refresh_button_size.width() / 2);
 258       // Stop button
 259       stop_button_ = new views::LabelButton(this, base::ASCIIToUTF16("Stop"));
 260       stop_button_->SetStyle(views::Button::STYLE_BUTTON);
 261       gfx::Size stop_button_size = stop_button_->GetPreferredSize();
 262       toolbar_column_set->AddColumn(views::GridLayout::CENTER,
 263                                     views::GridLayout::CENTER, 0,
 264                                     views::GridLayout::FIXED,
 265                                     stop_button_size.width(),
 266                                     stop_button_size.width() / 2);
 267       toolbar_column_set->AddPaddingColumn(0, 2);
 268       // URL entry
 269       url_entry_ = new views::Textfield();
 270       url_entry_->set_controller(this);
 271       toolbar_column_set->AddColumn(views::GridLayout::FILL,
 272                                     views::GridLayout::FILL, 1,
 273                                     views::GridLayout::USE_PREF, 0, 0);
 274       toolbar_column_set->AddPaddingColumn(0, 2);
 275
 276       // Fill up the first row
 277       toolbar_layout->StartRow(0, 0);
 278       toolbar_layout->AddView(back_button_);
 279       toolbar_layout->AddView(forward_button_);
 280       toolbar_layout->AddView(refresh_button_);
 281       toolbar_layout->AddView(stop_button_);
 282       toolbar_layout->AddView(url_entry_);
 283
 284       layout->AddView(toolbar_view_);
 285     }
 286
 287     layout->AddPaddingRow(0, 5);
 288
 289     // Add web contents view as the second row
 290     {
 291       layout->StartRow(1, 0);
 292       layout->AddView(contents_view_);
 293     }
 294
 295     layout->AddPaddingRow(0, 5);
 296
 297     InitAccelerators();
 298   }
 299   void InitAccelerators() {
 300     static const ui::KeyboardCode keys[] = { ui::VKEY_F5,
 301                                              ui::VKEY_BROWSER_BACK,
 302                                              ui::VKEY_BROWSER_FORWARD };
 303     for (size_t i = 0; i < arraysize(keys); ++i) {
 304       GetFocusManager()->RegisterAccelerator(
 305         ui::Accelerator(keys[i], ui::EF_NONE),
 306         ui::AcceleratorManager::kNormalPriority,
 307         this);
 308     }
 309   }
 310   // Overridden from TextfieldController
 311   virtual void ContentsChanged(views::Textfield* sender,
 312                                const base::string16& new_contents) OVERRIDE {
 313   }
 314   virtual bool HandleKeyEvent(views::Textfield* sender,
 315                               const ui::KeyEvent& key_event) OVERRIDE {
 316    if (sender == url_entry_ && key_event.key_code() == ui::VKEY_RETURN) {
 317      std::string text = base::UTF16ToUTF8(url_entry_->text());
 318      GURL url(text);
 319      if (!url.has_scheme()) {
 320        url = GURL(std::string("http://") + std::string(text));
 321        url_entry_->SetText(base::ASCIIToUTF16(url.spec()));
 322      }
 323      shell_->LoadURL(url);
 324      return true;
 325    }
 326    return false;
 327   }
 328
 329   // Overridden from ButtonListener
 330   virtual void ButtonPressed(views::Button* sender,
 331                              const ui::Event& event) OVERRIDE {
 332     if (sender == back_button_)
 333       shell_->GoBackOrForward(-1);
 334     else if (sender == forward_button_)
 335       shell_->GoBackOrForward(1);
 336     else if (sender == refresh_button_)
 337       shell_->Reload();
 338     else if (sender == stop_button_)
 339       shell_->Stop();
 340   }
 341
 342   // Overridden from WidgetDelegateView
 343   virtual bool CanResize() const OVERRIDE { return true; }
 344   virtual bool CanMaximize() const OVERRIDE { return true; }
 345   virtual base::string16 GetWindowTitle() const OVERRIDE {
 346     return title_;
 347   }
 348   virtual void WindowClosing() OVERRIDE {
 349     if (shell_) {
 350       delete shell_;
 351       shell_ = NULL;
 352     }
 353   }
 354   virtual View* GetContentsView() OVERRIDE { return this; }
 355
 356   // Overridden from View
 357   virtual gfx::Size GetMinimumSize() const OVERRIDE {
 358     // We want to be able to make the window smaller than its initial
 359     // (preferred) size.
 360     return gfx::Size();
 361   }
 362   virtual void ViewHierarchyChanged(
 363       const ViewHierarchyChangedDetails& details) OVERRIDE {
 364     if (details.is_add && details.child == this) {
 365       InitShellWindow();
 366     }
 367   }
 368
 369   // Overridden from AcceleratorTarget:
 370   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE {
 371     switch (accelerator.key_code()) {
 372     case ui::VKEY_F5:
 373       shell_->Reload();
 374       return true;
 375     case ui::VKEY_BROWSER_BACK:
 376       shell_->GoBackOrForward(-1);
 377       return true;
 378     case ui::VKEY_BROWSER_FORWARD:
 379       shell_->GoBackOrForward(1);
 380       return true;
 381     default:
 382       return views::WidgetDelegateView::AcceleratorPressed(accelerator);
 383     }
 384   }
 385
 386  private:
 387   // Hold a reference of Shell for deleting it when the window is closing
 388   Shell* shell_;
 389
 390   // Window title
 391   base::string16 title_;
 392
 393   // Toolbar view contains forward/backward/reload button and URL entry
 394   View* toolbar_view_;
 395   views::LabelButton* back_button_;
 396   views::LabelButton* forward_button_;
 397   views::LabelButton* refresh_button_;
 398   views::LabelButton* stop_button_;
 399   views::Textfield* url_entry_;
 400   scoped_ptr<ContextMenuModel> context_menu_model_;
 401   scoped_ptr<views::MenuRunner> context_menu_runner_;
 402
 403   // Contents view contains the web contents view
 404   View* contents_view_;
 405   views::WebView* web_view_;
 406
 407   DISALLOW_COPY_AND_ASSIGN(ShellWindowDelegateView);
 408 };
 409
 410 }  // namespace
 411
 412 #if defined(OS_CHROMEOS)
 413 wm::WMTestHelper* Shell::wm_test_helper_ = NULL;
 414 gfx::Screen* Shell::test_screen_ = NULL;
 415 #endif
 416 views::ViewsDelegate* Shell::views_delegate_ = NULL;
 417
 418 // static
 419 void Shell::PlatformInitialize(const gfx::Size& default_window_size) {
 420 #if defined(OS_WIN)
 421   _setmode(_fileno(stdout), _O_BINARY);
 422   _setmode(_fileno(stderr), _O_BINARY);
 423 #endif
 424 #if defined(OS_CHROMEOS)
 425   chromeos::DBusThreadManager::Initialize();
 426   test_screen_ = aura::TestScreen::Create(gfx::Size());
 427   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, test_screen_);
 428   wm_test_helper_ = new wm::WMTestHelper(default_window_size,
 429                                          GetContextFactory());
 430 #else
 431   gfx::Screen::SetScreenInstance(
 432       gfx::SCREEN_TYPE_NATIVE, views::CreateDesktopScreen());
 433 #endif
 434   views_delegate_ = new ShellViewsDelegateAura();
 435 }
 436
 437 void Shell::PlatformExit() {
 438 #if defined(OS_CHROMEOS)
 439   delete wm_test_helper_;
 440   wm_test_helper_ = NULL;
 441
 442   delete test_screen_;
 443   test_screen_ = NULL;
 444 #endif
 445   delete views_delegate_;
 446   views_delegate_ = NULL;
 447   delete platform_;
 448   platform_ = NULL;
 449 #if defined(OS_CHROMEOS)
 450   chromeos::DBusThreadManager::Shutdown();
 451 #endif
 452   aura::Env::DeleteInstance();
 453 }
 454
 455 void Shell::PlatformCleanUp() {
 456 }
 457
 458 void Shell::PlatformEnableUIControl(UIControl control, bool is_enabled) {
 459   if (headless_)
 460     return;
 461   ShellWindowDelegateView* delegate_view =
 462     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 463   if (control == BACK_BUTTON) {
 464     delegate_view->EnableUIControl(ShellWindowDelegateView::BACK_BUTTON,
 465         is_enabled);
 466   } else if (control == FORWARD_BUTTON) {
 467     delegate_view->EnableUIControl(ShellWindowDelegateView::FORWARD_BUTTON,
 468         is_enabled);
 469   } else if (control == STOP_BUTTON) {
 470     delegate_view->EnableUIControl(ShellWindowDelegateView::STOP_BUTTON,
 471         is_enabled);
 472   }
 473 }
 474
 475 void Shell::PlatformSetAddressBarURL(const GURL& url) {
 476   if (headless_)
 477     return;
 478   ShellWindowDelegateView* delegate_view =
 479     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 480   delegate_view->SetAddressBarURL(url);
 481 }
 482
 483 void Shell::PlatformSetIsLoading(bool loading) {
 484 }
 485
 486 void Shell::PlatformCreateWindow(int width, int height) {
 487   if (headless_) {
 488     content_size_ = gfx::Size(width, height);
 489     if (!platform_)
 490       platform_ = new ShellPlatformDataAura(content_size_);
 491     else
 492       platform_->ResizeWindow(content_size_);
 493     return;
 494   }
 495 #if defined(OS_CHROMEOS)
 496   window_widget_ = views::Widget::CreateWindowWithContextAndBounds(
 497       new ShellWindowDelegateView(this),
 498       wm_test_helper_->GetDefaultParent(NULL, NULL, gfx::Rect()),
 499       gfx::Rect(0, 0, width, height));
 500 #else
 501   window_widget_ = new views::Widget;
 502   views::Widget::InitParams params;
 503   params.bounds = gfx::Rect(0, 0, width, height);
 504   params.delegate = new ShellWindowDelegateView(this);
 505   window_widget_->Init(params);
 506 #endif
 507
 508   content_size_ = gfx::Size(width, height);
 509
 510   window_ = window_widget_->GetNativeWindow();
 511   // Call ShowRootWindow on RootWindow created by WMTestHelper without
 512   // which XWindow owned by RootWindow doesn't get mapped.
 513   window_->GetHost()->Show();
 514   window_widget_->Show();
 515 }
 516
 517 void Shell::PlatformSetContents() {
 518   if (headless_) {
 519     CHECK(platform_);
 520     aura::Window* content = web_contents_->GetNativeView();
 521     aura::Window* parent = platform_->host()->window();
 522     if (!parent->Contains(content)) {
 523       parent->AddChild(content);
 524       content->Show();
 525     }
 526     content->SetBounds(gfx::Rect(content_size_));
 527     RenderWidgetHostView* host_view = web_contents_->GetRenderWidgetHostView();
 528     if (host_view)
 529       host_view->SetSize(content_size_);
 530   } else {
 531     views::WidgetDelegate* widget_delegate = window_widget_->widget_delegate();
 532     ShellWindowDelegateView* delegate_view =
 533         static_cast<ShellWindowDelegateView*>(widget_delegate);
 534     delegate_view->SetWebContents(web_contents_.get(), content_size_);
 535   }
 536 }
 537
 538 void Shell::PlatformResizeSubViews() {
 539 }
 540
 541 void Shell::Close() {
 542   if (headless_)
 543     delete this;
 544   else
 545     window_widget_->CloseNow();
 546 }
 547
 548 void Shell::PlatformSetTitle(const base::string16& title) {
 549   if (headless_)
 550     return;
 551   ShellWindowDelegateView* delegate_view =
 552     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 553   delegate_view->SetWindowTitle(title);
 554   window_widget_->UpdateWindowTitle();
 555 }
 556
 557 bool Shell::PlatformHandleContextMenu(
 558     const content::ContextMenuParams& params) {
 559   if (headless_)
 560     return true;
 561   ShellWindowDelegateView* delegate_view =
 562     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 563   delegate_view->ShowWebViewContextMenu(params);
 564   return true;
 565 }
 566
 567 void Shell::PlatformWebContentsFocused(WebContents* contents) {
 568   if (headless_)
 569     return;
 570   ShellWindowDelegateView* delegate_view =
 571     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 572   delegate_view->OnWebContentsFocused(contents);
 573 }
 574
 575 }  // namespace content