Move focus from the view manager to the window manager.

mojo/services/view_manager/root_view_manager.cc

 // Copyright 2014 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.
 
 #include "mojo/services/view_manager/root_view_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/scoped_observer.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/services/view_manager/root_node_manager.h"
 #include "mojo/services/view_manager/root_view_manager_delegate.h"
 #include "mojo/services/view_manager/screen_impl.h"
 #include "mojo/services/view_manager/window_tree_host_impl.h"
 #include "ui/aura/client/default_capture_client.h"
-#include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 
 namespace mojo {
 namespace service {
 
-// TODO(sky): revisit this, we may need a more sophisticated FocusClient
-// implementation.
-class FocusClientImpl : public aura::client::FocusClient,
-                        public aura::WindowObserver {
+// TODO(sky): Remove once aura is removed from the service.
+class FocusClientImpl : public aura::client::FocusClient {
  public:
-  FocusClientImpl()
-      : focused_window_(NULL),
-        observer_manager_(this) {
-  }
+  FocusClientImpl() {}
   virtual ~FocusClientImpl() {}
 
  private:
   // Overridden from aura::client::FocusClient:
-  virtual void AddObserver(aura::client::FocusChangeObserver* observer)
-      OVERRIDE {
-    observers_.AddObserver(observer);
-  }
-  virtual void RemoveObserver(aura::client::FocusChangeObserver* observer)
-      OVERRIDE {
-    observers_.RemoveObserver(observer);
-  }
-  virtual void FocusWindow(aura::Window* window) OVERRIDE {
-    if (window && !window->CanFocus())
-      return;
-    if (window == focused_window_)
-      return;
-    if (focused_window_)
-      observer_manager_.Remove(focused_window_);
-    aura::Window* old_focused_window = focused_window_;
-    focused_window_ = window;
-    if (focused_window_)
-      observer_manager_.Add(focused_window_);
-
-    FOR_EACH_OBSERVER(aura::client::FocusChangeObserver,
-                      observers_,
-                      OnWindowFocused(focused_window_, old_focused_window));
-    aura::client::FocusChangeObserver* observer =
-        aura::client::GetFocusChangeObserver(old_focused_window);
-    if (observer)
-      observer->OnWindowFocused(focused_window_, old_focused_window);
-    observer = aura::client::GetFocusChangeObserver(focused_window_);
-    if (observer)
-      observer->OnWindowFocused(focused_window_, old_focused_window);
-  }
-  virtual void ResetFocusWithinActiveWindow(aura::Window* window) OVERRIDE {
-    if (!window->Contains(focused_window_))
-      FocusWindow(window);
-  }
-  virtual aura::Window* GetFocusedWindow() OVERRIDE {
-    return focused_window_;
-  }
-
-  // Overridden from WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
-    DCHECK_EQ(window, focused_window_);
-    FocusWindow(NULL);
-  }
-
-  aura::Window* focused_window_;
-  ScopedObserver<aura::Window, aura::WindowObserver> observer_manager_;
-  ObserverList<aura::client::FocusChangeObserver> observers_;
+  virtual void AddObserver(
+      aura::client::FocusChangeObserver* observer) OVERRIDE {}
+  virtual void RemoveObserver(
+      aura::client::FocusChangeObserver* observer) OVERRIDE {}
+  virtual void FocusWindow(aura::Window* window) OVERRIDE {}
+  virtual void ResetFocusWithinActiveWindow(aura::Window* window) OVERRIDE {}
+  virtual aura::Window* GetFocusedWindow() OVERRIDE { return NULL; }
 
   DISALLOW_COPY_AND_ASSIGN(FocusClientImpl);
 };
 
 class WindowTreeClientImpl : public aura::client::WindowTreeClient {
  public:
   explicit WindowTreeClientImpl(aura::Window* window) : window_(window) {
     aura::client::SetWindowTreeClient(window_, this);
   }
 
@@ skipping 31 matching lines @@
   screen_.reset(ScreenImpl::Create());
   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
   NativeViewportPtr viewport;
   app_connection->ConnectToService(
       "mojo:mojo_native_viewport_service", &viewport);
   window_tree_host_.reset(new WindowTreeHostImpl(
         viewport.Pass(),
         gfx::Rect(800, 600),
         base::Bind(&RootViewManager::OnCompositorCreated,
                    base::Unretained(this)),
-        native_viewport_closed_callback));
+        native_viewport_closed_callback,
+        base::Bind(&RootNodeManager::DispatchNodeInputEventToWindowManager,
+                   base::Unretained(root_node_manager_))));
 }
 
 RootViewManager::~RootViewManager() {
   window_tree_client_.reset();
   window_tree_host_.reset();
   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, NULL);
 }
 
 void RootViewManager::OnCompositorCreated() {
   base::AutoReset<bool> resetter(&in_setup_, true);
   window_tree_host_->InitHost();
 
   aura::Window* root = root_node_manager_->root()->window();
   window_tree_host_->window()->AddChild(root);
   root->SetBounds(gfx::Rect(window_tree_host_->window()->bounds().size()));
   root_node_manager_->root()->window()->Show();
 
   window_tree_client_.reset(
       new WindowTreeClientImpl(window_tree_host_->window()));
 
-  focus_client_.reset(new FocusClientImpl());
+  focus_client_.reset(new FocusClientImpl);
   aura::client::SetFocusClient(window_tree_host_->window(),
                                focus_client_.get());
-  focus_client_->AddObserver(root_node_manager_);
 
   window_tree_host_->Show();
 
   delegate_->OnRootViewManagerWindowTreeHostCreated();
 }
 
 }  // namespace service
 }  // namespace mojo