Home | History | Annotate | Download | only in browser 
      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 "content/public/browser/web_contents.h"
      8 #include "content/public/browser/web_contents_view.h"
      9 #include "content/shell/browser/shell_aura.h"
     10 #include "ui/aura/client/aura_constants.h"
     11 #include "ui/aura/client/default_activation_client.h"
     12 #include "ui/aura/client/default_capture_client.h"
     13 #include "ui/aura/env.h"
     14 #include "ui/aura/layout_manager.h"
     15 #include "ui/aura/root_window.h"
     16 #include "ui/aura/test/test_focus_client.h"
     17 #include "ui/aura/test/test_screen.h"
     18 #include "ui/aura/test/test_window_tree_client.h"
     19 #include "ui/aura/window.h"
     20 #include "ui/base/ime/input_method.h"
     21 #include "ui/base/ime/input_method_delegate.h"
     22 #include "ui/base/ime/input_method_factory.h"
     23 #include "ui/gfx/screen.h"
     24 
     25 namespace content {
     26 
     27 namespace {
     28 
     29 class FillLayout : public aura::LayoutManager {
     30  public:
     31   explicit FillLayout(aura::RootWindow* root)
     32       : root_(root) {
     33   }
     34 
     35   virtual ~FillLayout() {}
     36 
     37  private:
     38   // aura::LayoutManager:
     39   virtual void OnWindowResized() OVERRIDE {
     40   }
     41 
     42   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
     43     child->SetBounds(gfx::Rect(root_->host()->GetBounds().size()));
     44   }
     45 
     46   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {
     47   }
     48 
     49   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
     50   }
     51 
     52   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
     53                                               bool visible) OVERRIDE {
     54   }
     55 
     56   virtual void SetChildBounds(aura::Window* child,
     57                               const gfx::Rect& requested_bounds) OVERRIDE {
     58     SetChildBoundsDirect(child, requested_bounds);
     59   }
     60 
     61   aura::RootWindow* root_;
     62 
     63   DISALLOW_COPY_AND_ASSIGN(FillLayout);
     64 };
     65 
     66 class MinimalInputEventFilter : public ui::internal::InputMethodDelegate,
     67                                 public ui::EventHandler {
     68  public:
     69   explicit MinimalInputEventFilter(aura::RootWindow* root)
     70       : root_(root),
     71         input_method_(ui::CreateInputMethod(this,
     72                                             gfx::kNullAcceleratedWidget)) {
     73     input_method_->Init(true);
     74     root_->window()->AddPreTargetHandler(this);
     75     root_->window()->SetProperty(aura::client::kRootWindowInputMethodKey,
     76                        input_method_.get());
     77   }
     78 
     79   virtual ~MinimalInputEventFilter() {
     80     root_->window()->RemovePreTargetHandler(this);
     81     root_->window()->SetProperty(aura::client::kRootWindowInputMethodKey,
     82                        static_cast<ui::InputMethod*>(NULL));
     83   }
     84 
     85  private:
     86   // ui::EventHandler:
     87   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     88     const ui::EventType type = event->type();
     89     if (type == ui::ET_TRANSLATED_KEY_PRESS ||
     90         type == ui::ET_TRANSLATED_KEY_RELEASE) {
     91       // The |event| is already handled by this object, change the type of the
     92       // event to ui::ET_KEY_* and pass it to the next filter.
     93       static_cast<ui::TranslatedKeyEvent*>(event)->ConvertToKeyEvent();
     94     } else {
     95       if (input_method_->DispatchKeyEvent(*event))
     96         event->StopPropagation();
     97     }
     98   }
     99 
    100   // ui::InputMethodDelegate:
    101   virtual bool DispatchKeyEventPostIME(
    102       const base::NativeEvent& event) OVERRIDE {
    103     ui::TranslatedKeyEvent aura_event(event, false /* is_char */);
    104     return root_->AsRootWindowHostDelegate()->OnHostKeyEvent(
    105         &aura_event);
    106   }
    107 
    108   virtual bool DispatchFabricatedKeyEventPostIME(ui::EventType type,
    109                                                  ui::KeyboardCode key_code,
    110                                                  int flags) OVERRIDE {
    111     ui::TranslatedKeyEvent aura_event(type == ui::ET_KEY_PRESSED, key_code,
    112                                       flags);
    113     return root_->AsRootWindowHostDelegate()->OnHostKeyEvent(
    114         &aura_event);
    115   }
    116 
    117   aura::RootWindow* root_;
    118   scoped_ptr<ui::InputMethod> input_method_;
    119 
    120   DISALLOW_COPY_AND_ASSIGN(MinimalInputEventFilter);
    121 };
    122 
    123 }
    124 
    125 ShellAuraPlatformData* Shell::platform_ = NULL;
    126 
    127 ShellAuraPlatformData::ShellAuraPlatformData() {
    128   aura::TestScreen* screen = aura::TestScreen::Create();
    129   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen);
    130   root_window_.reset(screen->CreateRootWindowForPrimaryDisplay());
    131   root_window_->host()->Show();
    132   root_window_->window()->SetLayoutManager(new FillLayout(root_window_.get()));
    133 
    134   focus_client_.reset(new aura::test::TestFocusClient());
    135   aura::client::SetFocusClient(root_window_->window(), focus_client_.get());
    136 
    137   activation_client_.reset(
    138       new aura::client::DefaultActivationClient(root_window_->window()));
    139   capture_client_.reset(
    140       new aura::client::DefaultCaptureClient(root_window_->window()));
    141   window_tree_client_.reset(
    142       new aura::test::TestWindowTreeClient(root_window_->window()));
    143   ime_filter_.reset(new MinimalInputEventFilter(root_window_.get()));
    144 }
    145 
    146 ShellAuraPlatformData::~ShellAuraPlatformData() {
    147 }
    148 
    149 void ShellAuraPlatformData::ResizeWindow(int width, int height) {
    150   root_window_->SetHostSize(gfx::Size(width, height));
    151 }
    152 
    153 // static
    154 void Shell::PlatformInitialize(const gfx::Size& default_window_size) {
    155   CHECK(!platform_);
    156   aura::Env::CreateInstance();
    157   platform_ = new ShellAuraPlatformData();
    158 }
    159 
    160 void Shell::PlatformExit() {
    161   CHECK(platform_);
    162   delete platform_;
    163   platform_ = NULL;
    164   aura::Env::DeleteInstance();
    165 }
    166 
    167 void Shell::PlatformCleanUp() {
    168 }
    169 
    170 void Shell::PlatformEnableUIControl(UIControl control, bool is_enabled) {
    171 }
    172 
    173 void Shell::PlatformSetAddressBarURL(const GURL& url) {
    174 }
    175 
    176 void Shell::PlatformSetIsLoading(bool loading) {
    177 }
    178 
    179 void Shell::PlatformCreateWindow(int width, int height) {
    180   CHECK(platform_);
    181   platform_->ResizeWindow(width, height);
    182 }
    183 
    184 void Shell::PlatformSetContents() {
    185   CHECK(platform_);
    186   aura::Window* content = web_contents_->GetView()->GetNativeView();
    187   aura::Window* parent = platform_->window()->window();
    188   if (parent->Contains(content))
    189     return;
    190   parent->AddChild(content);
    191   content->Show();
    192 }
    193 
    194 void Shell::PlatformResizeSubViews() {
    195 }
    196 
    197 void Shell::Close() {
    198   web_contents_.reset();
    199 }
    200 
    201 void Shell::PlatformSetTitle(const base::string16& title) {
    202 }
    203 
    204 }  // namespace content
    205