Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / mojo / services / view_manager / root_view_manager.cc

diff --git a/src/mojo/services/view_manager/root_view_manager.cc b/src/mojo/services/view_manager/root_view_manager.cc
index 0bcdbfb..d44535d 100644 (file)
--- a/src/mojo/services/view_manager/root_view_manager.cc
+++ b/src/mojo/services/view_manager/root_view_manager.cc
@@ -6,75 +6,35 @@
 
 #include "base/auto_reset.h"
 #include "base/scoped_observer.h"
-#include "mojo/public/cpp/application/connect.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 view_manager {
 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 {
-  }
-  virtual void RemoveObserver(aura::client::FocusChangeObserver* observer)
-      OVERRIDE {
-  }
-  virtual void FocusWindow(aura::Window* window) OVERRIDE {
-    if (window && !window->CanFocus())
-      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_);
-
-    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_;
+  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);
 };
@@ -108,23 +68,27 @@ class WindowTreeClientImpl : public aura::client::WindowTreeClient {
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientImpl);
 };
 
-RootViewManager::RootViewManager(ServiceProvider* service_provider,
-                                 RootNodeManager* root_node,
-                                 RootViewManagerDelegate* delegate)
+RootViewManager::RootViewManager(
+    ApplicationConnection* app_connection,
+    RootNodeManager* root_node,
+    RootViewManagerDelegate* delegate,
+    const Callback<void()>& native_viewport_closed_callback)
     : delegate_(delegate),
       root_node_manager_(root_node),
       in_setup_(false) {
   screen_.reset(ScreenImpl::Create());
   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
   NativeViewportPtr viewport;
-  ConnectToService(service_provider,
-                   "mojo:mojo_native_viewport_service",
-                   &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))));
+                   base::Unretained(this)),
+        native_viewport_closed_callback,
+        base::Bind(&RootNodeManager::DispatchNodeInputEventToWindowManager,
+                   base::Unretained(root_node_manager_))));
 }
 
 RootViewManager::~RootViewManager() {
@@ -145,7 +109,7 @@ void RootViewManager::OnCompositorCreated() {
   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());
 
@@ -155,5 +119,4 @@ void RootViewManager::OnCompositorCreated() {
 }
 
 }  // namespace service
-}  // namespace view_manager
 }  // namespace mojo