Make content_shell and content_browsertests working with aura

content/shell/shell_aura.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-

[jochen (gone - plz use gerrit), 2012/07/23 15:21:47]

please keep this empty line

 #include "content/shell/shell.h"
 
+#include "base/utf_string_conversions.h"
+#include "ui/aura/desktop/desktop_screen.h"
+#include "ui/aura/desktop/desktop_stacking_client.h"
+#include "ui/aura/display_manager.h"
+#include "ui/aura/env.h"
+#include "ui/aura/root_window.h"
+#include "ui/aura/single_display_manager.h"
+#include "ui/base/accessibility/accessibility_types.h"
+#include "ui/base/clipboard/clipboard.h"
+#include "ui/gfx/screen.h"
+#include "ui/aura/window.h"

[jam, 2012/07/23 14:39:46]

nit: order

+#include "ui/base/resource/resource_bundle.h"
+#include "ui/views/controls/button/text_button.h"
+#include "ui/views/controls/textfield/textfield.h"
+#include "ui/views/controls/textfield/textfield_controller.h"
+#include "ui/views/controls/webview/webview.h"
+#include "ui/views/layout/fill_layout.h"
+#include "ui/views/layout/grid_layout.h"
+#include "ui/views/view.h"
+#include "ui/views/views_delegate.h"
+#include "ui/views/widget/desktop_native_widget_helper_aura.h"
+#include "ui/views/widget/widget.h"
+#include "ui/views/widget/widget_delegate.h"
+
+namespace views{

[jochen (gone - plz use gerrit), 2012/07/23 15:21:47]

space between views and {

+// ViewDelegate implementation for aura content shell
+class ShellViewsDelegateAura : public ViewsDelegate {
+ public:
+  ShellViewsDelegateAura()
+    : use_transparent_windows_(false) {
+    DCHECK(!ViewsDelegate::views_delegate);
+    ViewsDelegate::views_delegate = this;
+  }

[jochen (gone - plz use gerrit), 2012/07/23 15:21:47]

empty lines between methods.

This class is sufficiently complex that you could consider separating the
declaration and implementation

+  virtual ~ShellViewsDelegateAura() {
+    ViewsDelegate::views_delegate = NULL;
+  }
+
+  void SetUseTransparentWindows(bool transparent) {
+    use_transparent_windows_ = transparent;
+  }
+
+  // Overridden from ViewsDelegate:
+  virtual ui::Clipboard* GetClipboard() const OVERRIDE {
+    if (!clipboard_.get()) {
+      clipboard_.reset(new ui::Clipboard);
+    }
+    return clipboard_.get();
+  }
+  virtual void SaveWindowPlacement(const Widget* window,
+                                   const std::string& window_name,
+                                   const gfx::Rect& bounds,
+                                   ui::WindowShowState show_state) OVERRIDE {
+  }
+  virtual bool GetSavedWindowPlacement(
+      const std::string& window_name,
+      gfx::Rect* bounds,
+      ui::WindowShowState* show_state) const OVERRIDE {
+    return false;
+  }
+
+  virtual void NotifyAccessibilityEvent(
+      View* view, ui::AccessibilityTypes::Event event_type) OVERRIDE {}
+
+  virtual void NotifyMenuItemFocused(const string16& menu_name,
+                                     const string16& menu_item_name,
+                                     int item_index,
+                                     int item_count,
+                                     bool has_submenu) OVERRIDE {}
+#if defined(OS_WIN)
+  virtual HICON GetDefaultWindowIcon() const OVERRIDE {
+    return NULL;
+  }
+#endif
+  virtual NonClientFrameView* CreateDefaultNonClientFrameView(
+      Widget* widget) OVERRIDE {
+    return NULL;
+  }
+  virtual bool UseTransparentWindows() const OVERRIDE {
+    return use_transparent_windows_;
+  }
+  virtual void AddRef() OVERRIDE {}
+  virtual void ReleaseRef() OVERRIDE {}
+
+  virtual int GetDispositionForEvent(int event_flags) OVERRIDE {
+    return 0;
+  }
+
+  virtual views::NativeWidgetHelperAura* CreateNativeWidgetHelper(
+      views::NativeWidgetAura* native_widget) OVERRIDE {
+    return new views::DesktopNativeWidgetHelperAura(native_widget);
+  }
+
+  virtual content::WebContents* CreateWebContents(
+      content::BrowserContext* browser_context,
+      content::SiteInstance* site_instance) OVERRIDE {
+    return NULL;
+  }
+
+ private:
+  mutable scoped_ptr<ui::Clipboard> clipboard_;
+  bool use_transparent_windows_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShellViewsDelegateAura);
+};
+
+// Maintain the UI controls and web view for content shell
+class ShellWindowDelegateView : public WidgetDelegateView,
+                                public TextfieldController,
+                                public ButtonListener {
+ public:
+  enum UIControl {
+    BACK_BUTTON,
+    FORWARD_BUTTON,
+    STOP_BUTTON
+  };
+
+  ShellWindowDelegateView(content::Shell* shell)

[jochen (gone - plz use gerrit), 2012/07/23 15:21:47]

explicit

+    : shell_(shell),
+      toolbar_view_(new View),
+      contents_view_(new View) {
+  }
+  ~ShellWindowDelegateView() {}

[jochen (gone - plz use gerrit), 2012/07/23 15:21:47]

virtual

+
+  // Update the state of UI controls
+  void SetAddressBarURL(const GURL& url);

[jochen (gone - plz use gerrit), 2012/07/23 15:21:47]

please separate the declaration and implementation for all methods

[jam, 2012/07/23 22:55:55]

I actually prefer when they're inline if the class is defined in a cc file :) I
find that separating them takes more scrolling to read the class, and having the
functions right beside each other isn't always helpful for readability (i.e.
method names, without looking at the code, aren't that useful).

+  void SetWebContents(content::WebContents* web_contents);
+  void SetWindowTitle(const string16& title) { title_ = title; }
+  void EnableUIControl(UIControl control, bool is_enabled);
+
+ private:
+  // Initialize the UI control contained in shell window
+  void InitShellWindow();
+
+  // Overriden from TextfieldController
+  virtual void ContentsChanged(Textfield* sender,
+                               const string16& new_contents) OVERRIDE {
+  }
+  virtual bool HandleKeyEvent(Textfield* sender,
+                              const KeyEvent& key_event) OVERRIDE;
+
+  // Overriden from ButtonListener
+  virtual void ButtonPressed(Button* sender,
+      const Event& event) OVERRIDE;
+
+  // Overriden from WidgetDelegateView
+  virtual bool CanResize() const OVERRIDE { return true; }
+  virtual bool CanMaximize() const OVERRIDE { return true; }
+  virtual string16 GetWindowTitle() const OVERRIDE {
+    return title_;
+  }
+  virtual void WindowClosing() OVERRIDE {
+    if (shell_) delete shell_;
+  }
+  virtual View* GetContentsView() OVERRIDE { return this; }
+
+  // Overriden from View
+  virtual void ViewHierarchyChanged(bool is_add,
+                                    View* parent,
+                                    View* child) OVERRIDE {
+    if (is_add && child == this) {
+      InitShellWindow();
+    }
+  }
+
+ private:
+  // Hold a reference of Shell for deleting it when the window is closing
+  content::Shell* shell_;
+
+  // Window title
+  string16 title_;
+
+  // Toolbar view contains forward/backward/reload button and URL entry
+  View* toolbar_view_;
+  NativeTextButton* back_button_;
+  NativeTextButton* forward_button_;
+  NativeTextButton* refresh_button_;
+  NativeTextButton* stop_button_;
+  Textfield* url_entry_;
+
+  // Contents view contains the web contents view
+  View* contents_view_;
+  WebView* web_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShellWindowDelegateView);
+};
+
+// ShellWindowDelegateView implelementation
+void ShellWindowDelegateView::SetAddressBarURL(const GURL& url) {
+  url_entry_->SetText(ASCIIToUTF16(url.spec()));
+}
+
+void ShellWindowDelegateView::SetWebContents(
+    content::WebContents* web_contents) {
+  contents_view_->SetLayoutManager(new FillLayout());
+  web_view_ = new WebView(web_contents->GetBrowserContext());
+  web_view_->SetWebContents(web_contents);
+  web_contents->Focus();
+  contents_view_->AddChildView(web_view_);
+  Layout();
+}
+
+void ShellWindowDelegateView::EnableUIControl(UIControl control,
+    bool is_enabled) {
+  if (control == BACK_BUTTON) {
+    back_button_->SetState(is_enabled ? CustomButton::BS_NORMAL
+        : CustomButton::BS_DISABLED);
+  } else if (control == FORWARD_BUTTON) {
+    forward_button_->SetState(is_enabled ? CustomButton::BS_NORMAL
+        : CustomButton::BS_DISABLED);
+  } else if (control == STOP_BUTTON) {
+    stop_button_->SetState(is_enabled ? CustomButton::BS_NORMAL
+        : CustomButton::BS_DISABLED);
+  }
+}
+
+// Overriden from TextfieldController
+bool ShellWindowDelegateView::HandleKeyEvent(Textfield* sender,
+    const KeyEvent& key_event) OVERRIDE {
+  if (sender == url_entry_ && key_event.key_code() == ui::VKEY_RETURN) {
+    std::string text = UTF16ToUTF8(url_entry_->text());
+    GURL url(text);
+    if (!url.has_scheme()) {
+      url = GURL(std::string("http://") + std::string(text));
+      url_entry_->SetText(ASCIIToUTF16(url.spec()));
+    }
+    shell_->LoadURL(url);
+    return true;
+  }
+  return false;
+}
+
+// Overriden from ButtonListener
+void ShellWindowDelegateView::ButtonPressed(Button* sender,
+    const Event& event) OVERRIDE {
+  if (sender == back_button_)
+    shell_->GoBackOrForward(-1);
+  else if (sender == forward_button_)
+    shell_->GoBackOrForward(1);
+  else if (sender == refresh_button_)
+    shell_->Reload();
+  else if (sender == stop_button_)
+    shell_->Stop();
+}
+
+void ShellWindowDelegateView::InitShellWindow() {
+  set_background(Background::CreateStandardPanelBackground());
+
+  GridLayout* layout = new GridLayout(this);
+  SetLayoutManager(layout);
+
+  ColumnSet* column_set = layout->AddColumnSet(0);
+  column_set->AddPaddingColumn(0, 2);
+  column_set->AddColumn(GridLayout::FILL, GridLayout::FILL, 1,
+                        GridLayout::USE_PREF, 0, 0);
+  column_set->AddPaddingColumn(0, 2);
+
+  layout->AddPaddingRow(0, 2);
+
+  // Add toolbar buttons and URL text field
+  {
+    layout->StartRow(0, 0);
+    GridLayout* toolbar_layout = new GridLayout(toolbar_view_);
+    toolbar_view_->SetLayoutManager(toolbar_layout);
+
+    ColumnSet* toolbar_column_set =
+        toolbar_layout->AddColumnSet(0);
+    // Back button
+    back_button_ = new NativeTextButton(this, ASCIIToUTF16("Back"));
+    gfx::Size back_button_size = back_button_->GetPreferredSize();
+    toolbar_column_set->AddColumn(GridLayout::CENTER,
+                                  GridLayout::CENTER, 0,
+                                  GridLayout::FIXED,
+                                  back_button_size.width(),
+                                  back_button_size.width() / 2);
+    // Forward button
+    forward_button_ = new NativeTextButton(this, ASCIIToUTF16("Forward"));
+    gfx::Size forward_button_size = forward_button_->GetPreferredSize();
+    toolbar_column_set->AddColumn(GridLayout::CENTER,
+                                  GridLayout::CENTER, 0,
+                                  GridLayout::FIXED,
+                                  forward_button_size.width(),
+                                  forward_button_size.width() / 2);
+    // Refresh button
+    refresh_button_ = new NativeTextButton(this, ASCIIToUTF16("Refresh"));
+    gfx::Size refresh_button_size = refresh_button_->GetPreferredSize();
+    toolbar_column_set->AddColumn(GridLayout::CENTER,
+                                  GridLayout::CENTER, 0,
+                                  GridLayout::FIXED,
+                                  refresh_button_size.width(),
+                                  refresh_button_size.width() / 2);
+    // Stop button
+    stop_button_ = new NativeTextButton(this, ASCIIToUTF16("Stop"));
+    gfx::Size stop_button_size = stop_button_->GetPreferredSize();
+    toolbar_column_set->AddColumn(GridLayout::CENTER,
+                                  GridLayout::CENTER, 0,
+                                  GridLayout::FIXED,
+                                  stop_button_size.width(),
+                                  stop_button_size.width() / 2);
+    toolbar_column_set->AddPaddingColumn(0, 2);
+    // URL entry
+    url_entry_ = new Textfield();
+    url_entry_->SetController(this);
+    toolbar_column_set->AddColumn(GridLayout::FILL,
+                                  GridLayout::FILL, 1,
+                                  GridLayout::USE_PREF, 0, 0);
+
+    // Fill up the first row
+    toolbar_layout->StartRow(0, 0);
+    toolbar_layout->AddView(back_button_);
+    toolbar_layout->AddView(forward_button_);
+    toolbar_layout->AddView(refresh_button_);
+    toolbar_layout->AddView(stop_button_);
+    toolbar_layout->AddView(url_entry_);
+
+    layout->AddView(toolbar_view_);
+  }
+
+  layout->AddPaddingRow(0, 5);
+
+  // Add web contents view as the second row
+  {
+    layout->StartRow(1, 0);
+    layout->AddView(contents_view_);
+  }
+
+  layout->AddPaddingRow(0, 5);
+}
+}  // namespace views
+
 namespace content {
 
+using views::ShellWindowDelegateView;
+using views::ShellViewsDelegateAura;
+
+scoped_ptr<aura::client::StackingClient> Shell::stacking_client_;

[jam, 2012/07/23 14:39:46]

only pod are allowed as statics per chrome style guide. so you can make this a
naked pointer and delete it manually

+scoped_ptr<views::ViewsDelegate> Shell::views_delegate_;
 // static
 void Shell::PlatformInitialize() {
+  aura::Env::GetInstance()->SetDisplayManager(new aura::SingleDisplayManager);
+  stacking_client_.reset(new aura::DesktopStackingClient);
+  gfx::Screen::SetInstance(aura::CreateDesktopScreen());
+  views_delegate_.reset(new ShellViewsDelegateAura);
+
+  // Loading locale resources for Widget::CreateWindowWithBounds initialization
+  // in which CustomFrameView requires the accessible name for buttons.
+  ui::ResourceBundle::GetSharedInstance().ReloadLocaleResources("en-US");
 }
 
 base::StringPiece Shell::PlatformResourceProvider(int key) {
   return base::StringPiece();
 }
 
 void Shell::PlatformExit() {
+  stacking_client_.reset();
+  views_delegate_.reset();
+  aura::Env::DeleteInstance();
 }
 
 void Shell::PlatformCleanUp() {
 }
 
 void Shell::PlatformEnableUIControl(UIControl control, bool is_enabled) {
+  ShellWindowDelegateView* delegate_view =
+    static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
+  if (control == BACK_BUTTON) {
+    delegate_view->EnableUIControl(ShellWindowDelegateView::BACK_BUTTON,
+        is_enabled);
+  } else if (control == FORWARD_BUTTON) {
+    delegate_view->EnableUIControl(ShellWindowDelegateView::FORWARD_BUTTON,
+        is_enabled);
+  } else if (control == STOP_BUTTON) {
+    delegate_view->EnableUIControl(ShellWindowDelegateView::STOP_BUTTON,
+        is_enabled);
+  }
 }
 
 void Shell::PlatformSetAddressBarURL(const GURL& url) {
+  ShellWindowDelegateView* delegate_view =
+    static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
+  delegate_view->SetAddressBarURL(url);
 }
 
 void Shell::PlatformSetIsLoading(bool loading) {
 }
 
 void Shell::PlatformCreateWindow(int width, int height) {
+  window_widget_ =
+      views::Widget::CreateWindowWithBounds(new ShellWindowDelegateView(this),
+               gfx::Rect(0, 0, width, height));
+  window_ = window_widget_->GetNativeWindow();
+  window_widget_->Show();
 }
 
 void Shell::PlatformSetContents() {
+  ShellWindowDelegateView* delegate_view =
+    static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
+  delegate_view->SetWebContents(web_contents_.get());
 }
 
 void Shell::PlatformResizeSubViews() {
 }
 
 void Shell::Close() {
+  window_widget_->Close();
 }
 
 void Shell::PlatformSetTitle(const string16& title) {
+  ShellWindowDelegateView* delegate_view =
+    static_cast<ShellWindowDelegateView*>(window_widget_->widget_delegate());
+  delegate_view->SetWindowTitle(title);
+  window_widget_->UpdateWindowTitle();
 }
 
 }  // namespace content