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(
 188         new views::MenuRunner(context_menu_model_.get()));
 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::CONTEXT_MENU) ==
 196         views::MenuRunner::MENU_DELETED) {
 197       return;
 198     }
 199   }
 200
 201   void OnWebContentsFocused(content::WebContents* web_contents) {
 202     if (web_view_->GetWebContents() == web_contents)
 203       web_view_->OnWebContentsFocused(web_contents);
 204   }
 205
 206  private:
 207   // Initialize the UI control contained in shell window
 208   void InitShellWindow() {
 209     set_background(views::Background::CreateStandardPanelBackground());
 210
 211     views::GridLayout* layout = new views::GridLayout(this);
 212     SetLayoutManager(layout);
 213
 214     views::ColumnSet* column_set = layout->AddColumnSet(0);
 215     column_set->AddPaddingColumn(0, 2);
 216     column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
 217                           views::GridLayout::USE_PREF, 0, 0);
 218     column_set->AddPaddingColumn(0, 2);
 219
 220     layout->AddPaddingRow(0, 2);
 221
 222     // Add toolbar buttons and URL text field
 223     {
 224       layout->StartRow(0, 0);
 225       views::GridLayout* toolbar_layout = new views::GridLayout(toolbar_view_);
 226       toolbar_view_->SetLayoutManager(toolbar_layout);
 227
 228       views::ColumnSet* toolbar_column_set =
 229           toolbar_layout->AddColumnSet(0);
 230       // Back button
 231       back_button_ = new views::LabelButton(this, base::ASCIIToUTF16("Back"));
 232       back_button_->SetStyle(views::Button::STYLE_BUTTON);
 233       gfx::Size back_button_size = back_button_->GetPreferredSize();
 234       toolbar_column_set->AddColumn(views::GridLayout::CENTER,
 235                                     views::GridLayout::CENTER, 0,
 236                                     views::GridLayout::FIXED,
 237                                     back_button_size.width(),
 238                                     back_button_size.width() / 2);
 239       // Forward button
 240       forward_button_ =
 241           new views::LabelButton(this, base::ASCIIToUTF16("Forward"));
 242       forward_button_->SetStyle(views::Button::STYLE_BUTTON);
 243       gfx::Size forward_button_size = forward_button_->GetPreferredSize();
 244       toolbar_column_set->AddColumn(views::GridLayout::CENTER,
 245                                     views::GridLayout::CENTER, 0,
 246                                     views::GridLayout::FIXED,
 247                                     forward_button_size.width(),
 248                                     forward_button_size.width() / 2);
 249       // Refresh button
 250       refresh_button_ =
 251           new views::LabelButton(this, base::ASCIIToUTF16("Refresh"));
 252       refresh_button_->SetStyle(views::Button::STYLE_BUTTON);
 253       gfx::Size refresh_button_size = refresh_button_->GetPreferredSize();
 254       toolbar_column_set->AddColumn(views::GridLayout::CENTER,
 255                                     views::GridLayout::CENTER, 0,
 256                                     views::GridLayout::FIXED,
 257                                     refresh_button_size.width(),
 258                                     refresh_button_size.width() / 2);
 259       // Stop button
 260       stop_button_ = new views::LabelButton(this, base::ASCIIToUTF16("Stop"));
 261       stop_button_->SetStyle(views::Button::STYLE_BUTTON);
 262       gfx::Size stop_button_size = stop_button_->GetPreferredSize();
 263       toolbar_column_set->AddColumn(views::GridLayout::CENTER,
 264                                     views::GridLayout::CENTER, 0,
 265                                     views::GridLayout::FIXED,
 266                                     stop_button_size.width(),
 267                                     stop_button_size.width() / 2);
 268       toolbar_column_set->AddPaddingColumn(0, 2);
 269       // URL entry
 270       url_entry_ = new views::Textfield();
 271       url_entry_->set_controller(this);
 272       toolbar_column_set->AddColumn(views::GridLayout::FILL,
 273                                     views::GridLayout::FILL, 1,
 274                                     views::GridLayout::USE_PREF, 0, 0);
 275       toolbar_column_set->AddPaddingColumn(0, 2);
 276
 277       // Fill up the first row
 278       toolbar_layout->StartRow(0, 0);
 279       toolbar_layout->AddView(back_button_);
 280       toolbar_layout->AddView(forward_button_);
 281       toolbar_layout->AddView(refresh_button_);
 282       toolbar_layout->AddView(stop_button_);
 283       toolbar_layout->AddView(url_entry_);
 284
 285       layout->AddView(toolbar_view_);
 286     }
 287
 288     layout->AddPaddingRow(0, 5);
 289
 290     // Add web contents view as the second row
 291     {
 292       layout->StartRow(1, 0);
 293       layout->AddView(contents_view_);
 294     }
 295
 296     layout->AddPaddingRow(0, 5);
 297
 298     InitAccelerators();
 299   }
 300   void InitAccelerators() {
 301     static const ui::KeyboardCode keys[] = { ui::VKEY_F5,
 302                                              ui::VKEY_BROWSER_BACK,
 303                                              ui::VKEY_BROWSER_FORWARD };
 304     for (size_t i = 0; i < arraysize(keys); ++i) {
 305       GetFocusManager()->RegisterAccelerator(
 306         ui::Accelerator(keys[i], ui::EF_NONE),
 307         ui::AcceleratorManager::kNormalPriority,
 308         this);
 309     }
 310   }
 311   // Overridden from TextfieldController
 312   virtual void ContentsChanged(views::Textfield* sender,
 313                                const base::string16& new_contents) OVERRIDE {
 314   }
 315   virtual bool HandleKeyEvent(views::Textfield* sender,
 316                               const ui::KeyEvent& key_event) OVERRIDE {
 317    if (sender == url_entry_ && key_event.key_code() == ui::VKEY_RETURN) {
 318      std::string text = base::UTF16ToUTF8(url_entry_->text());
 319      GURL url(text);
 320      if (!url.has_scheme()) {
 321        url = GURL(std::string("http://") + std::string(text));
 322        url_entry_->SetText(base::ASCIIToUTF16(url.spec()));
 323      }
 324      shell_->LoadURL(url);
 325      return true;
 326    }
 327    return false;
 328   }
 329
 330   // Overridden from ButtonListener
 331   virtual void ButtonPressed(views::Button* sender,
 332                              const ui::Event& event) OVERRIDE {
 333     if (sender == back_button_)
 334       shell_->GoBackOrForward(-1);
 335     else if (sender == forward_button_)
 336       shell_->GoBackOrForward(1);
 337     else if (sender == refresh_button_)
 338       shell_->Reload();
 339     else if (sender == stop_button_)
 340       shell_->Stop();
 341   }
 342
 343   // Overridden from WidgetDelegateView
 344   virtual bool CanResize() const OVERRIDE { return true; }
 345   virtual bool CanMaximize() const OVERRIDE { return true; }
 346   virtual base::string16 GetWindowTitle() const OVERRIDE {
 347     return title_;
 348   }
 349   virtual void WindowClosing() OVERRIDE {
 350     if (shell_) {
 351       delete shell_;
 352       shell_ = NULL;
 353     }
 354   }
 355   virtual View* GetContentsView() OVERRIDE { return this; }
 356
 357   // Overridden from View
 358   virtual gfx::Size GetMinimumSize() const OVERRIDE {
 359     // We want to be able to make the window smaller than its initial
 360     // (preferred) size.
 361     return gfx::Size();
 362   }
 363   virtual void ViewHierarchyChanged(
 364       const ViewHierarchyChangedDetails& details) OVERRIDE {
 365     if (details.is_add && details.child == this) {
 366       InitShellWindow();
 367     }
 368   }
 369
 370   // Overridden from AcceleratorTarget:
 371   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE {
 372     switch (accelerator.key_code()) {
 373     case ui::VKEY_F5:
 374       shell_->Reload();
 375       return true;
 376     case ui::VKEY_BROWSER_BACK:
 377       shell_->GoBackOrForward(-1);
 378       return true;
 379     case ui::VKEY_BROWSER_FORWARD:
 380       shell_->GoBackOrForward(1);
 381       return true;
 382     default:
 383       return views::WidgetDelegateView::AcceleratorPressed(accelerator);
 384     }
 385   }
 386
 387  private:
 388   // Hold a reference of Shell for deleting it when the window is closing
 389   Shell* shell_;
 390
 391   // Window title
 392   base::string16 title_;
 393
 394   // Toolbar view contains forward/backward/reload button and URL entry
 395   View* toolbar_view_;
 396   views::LabelButton* back_button_;
 397   views::LabelButton* forward_button_;
 398   views::LabelButton* refresh_button_;
 399   views::LabelButton* stop_button_;
 400   views::Textfield* url_entry_;
 401   scoped_ptr<ContextMenuModel> context_menu_model_;
 402   scoped_ptr<views::MenuRunner> context_menu_runner_;
 403
 404   // Contents view contains the web contents view
 405   View* contents_view_;
 406   views::WebView* web_view_;
 407
 408   DISALLOW_COPY_AND_ASSIGN(ShellWindowDelegateView);
 409 };
 410
 411 }  // namespace
 412
 413 #if defined(OS_CHROMEOS)
 414 wm::WMTestHelper* Shell::wm_test_helper_ = 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   gfx::Screen::SetScreenInstance(
 427       gfx::SCREEN_TYPE_NATIVE, aura::TestScreen::Create());
 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 #endif
 441   delete views_delegate_;
 442   views_delegate_ = NULL;
 443   delete platform_;
 444   platform_ = NULL;
 445 #if defined(OS_CHROMEOS)
 446   chromeos::DBusThreadManager::Shutdown();
 447 #endif
 448   aura::Env::DeleteInstance();
 449 }
 450
 451 void Shell::PlatformCleanUp() {
 452 }
 453
 454 void Shell::PlatformEnableUIControl(UIControl control, bool is_enabled) {
 455   if (headless_)
 456     return;
 457   ShellWindowDelegateView* delegate_view =
 458     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 459   if (control == BACK_BUTTON) {
 460     delegate_view->EnableUIControl(ShellWindowDelegateView::BACK_BUTTON,
 461         is_enabled);
 462   } else if (control == FORWARD_BUTTON) {
 463     delegate_view->EnableUIControl(ShellWindowDelegateView::FORWARD_BUTTON,
 464         is_enabled);
 465   } else if (control == STOP_BUTTON) {
 466     delegate_view->EnableUIControl(ShellWindowDelegateView::STOP_BUTTON,
 467         is_enabled);
 468   }
 469 }
 470
 471 void Shell::PlatformSetAddressBarURL(const GURL& url) {
 472   if (headless_)
 473     return;
 474   ShellWindowDelegateView* delegate_view =
 475     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 476   delegate_view->SetAddressBarURL(url);
 477 }
 478
 479 void Shell::PlatformSetIsLoading(bool loading) {
 480 }
 481
 482 void Shell::PlatformCreateWindow(int width, int height) {
 483   if (headless_) {
 484     content_size_ = gfx::Size(width, height);
 485     if (!platform_)
 486       platform_ = new ShellPlatformDataAura(content_size_);
 487     else
 488       platform_->ResizeWindow(content_size_);
 489     return;
 490   }
 491 #if defined(OS_CHROMEOS)
 492   window_widget_ = views::Widget::CreateWindowWithContextAndBounds(
 493       new ShellWindowDelegateView(this),
 494       wm_test_helper_->GetDefaultParent(NULL, NULL, gfx::Rect()),
 495       gfx::Rect(0, 0, width, height));
 496 #else
 497   window_widget_ = new views::Widget;
 498   views::Widget::InitParams params;
 499   params.bounds = gfx::Rect(0, 0, width, height);
 500   params.delegate = new ShellWindowDelegateView(this);
 501   params.remove_standard_frame = true;
 502   window_widget_->Init(params);
 503 #endif
 504
 505   content_size_ = gfx::Size(width, height);
 506
 507   window_ = window_widget_->GetNativeWindow();
 508   // Call ShowRootWindow on RootWindow created by WMTestHelper without
 509   // which XWindow owned by RootWindow doesn't get mapped.
 510   window_->GetHost()->Show();
 511   window_widget_->Show();
 512 }
 513
 514 void Shell::PlatformSetContents() {
 515   if (headless_) {
 516     CHECK(platform_);
 517     aura::Window* content = web_contents_->GetNativeView();
 518     aura::Window* parent = platform_->host()->window();
 519     if (!parent->Contains(content)) {
 520       parent->AddChild(content);
 521       content->Show();
 522     }
 523     content->SetBounds(gfx::Rect(content_size_));
 524     RenderWidgetHostView* host_view = web_contents_->GetRenderWidgetHostView();
 525     if (host_view)
 526       host_view->SetSize(content_size_);
 527   } else {
 528     views::WidgetDelegate* widget_delegate = window_widget_->widget_delegate();
 529     ShellWindowDelegateView* delegate_view =
 530         static_cast<ShellWindowDelegateView*>(widget_delegate);
 531     delegate_view->SetWebContents(web_contents_.get(), content_size_);
 532   }
 533 }
 534
 535 void Shell::PlatformResizeSubViews() {
 536 }
 537
 538 void Shell::Close() {
 539   if (headless_)
 540     delete this;
 541   else
 542     window_widget_->CloseNow();
 543 }
 544
 545 void Shell::PlatformSetTitle(const base::string16& title) {
 546   if (headless_)
 547     return;
 548   ShellWindowDelegateView* delegate_view =
 549     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 550   delegate_view->SetWindowTitle(title);
 551   window_widget_->UpdateWindowTitle();
 552 }
 553
 554 bool Shell::PlatformHandleContextMenu(
 555     const content::ContextMenuParams& params) {
 556   if (headless_)
 557     return true;
 558   ShellWindowDelegateView* delegate_view =
 559     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 560   delegate_view->ShowWebViewContextMenu(params);
 561   return true;
 562 }
 563
 564 void Shell::PlatformWebContentsFocused(WebContents* contents) {
 565   if (headless_)
 566     return;
 567   ShellWindowDelegateView* delegate_view =
 568     static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
 569   delegate_view->OnWebContentsFocused(contents);
 570 }
 571
 572 }  // namespace content