Add ability APIs for opening a window with a url embedded, focusing and activating a window.

R=sky@chromium.org
BUG=none

Review URL: https://codereview.chromium.org/405523002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@284246 0039d316-1c4b-4281-b951-d872f2087c98

mojo/mojo_services.gypi

@@ -813,6 +813,7 @@
             'mojo_shell_test_support',
             'mojo_system_impl',
             'mojo_view_manager_bindings',
+            'mojo_view_manager_lib',
           ],
           'sources': [
             'services/window_manager/window_manager_api_unittest.cc',

mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.cc

@@ -532,7 +532,6 @@ ViewManagerClientImpl::ViewManagerClientImpl(ApplicationConnection* connection,
       dispatcher_(NULL) {}
 
 ViewManagerClientImpl::~ViewManagerClientImpl() {
-  delegate_->OnViewManagerDisconnected(this);
   while (!nodes_.empty()) {
     IdToNodeMap::iterator it = nodes_.begin();
     if (OwnsNode(it->second->id()))
@@ -547,6 +546,7 @@ ViewManagerClientImpl::~ViewManagerClientImpl() {
     else
       views_.erase(it);
   }
+  delegate_->OnViewManagerDisconnected(this);
 }
 
 Id ViewManagerClientImpl::CreateNode() {

mojo/services/public/interfaces/window_manager/window_manager.mojom

@@ -7,7 +7,10 @@ module mojo {
 [Client=WindowManagerClient]
 interface WindowManagerService {
   OpenWindow() => (uint32 node_id);
+  OpenWindowWithURL(string url) => (uint32 node_id);
   SetCapture(uint32 node_id) => (bool success);
+  FocusWindow(uint32 node_id) => (bool success);
+  ActivateWindow(uint32 node_id) => (bool success);
 };
 
 [Client=WindowManagerService]
@@ -19,6 +22,9 @@ interface WindowManagerClient {
   // TODO(beng): how is the WM supposed to know if a node is known to a client
   //             or not?
   OnCaptureChanged(uint32 old_capture_node_id, uint32 new_capture_node_id);
+
+  OnFocusChanged(uint32 old_focused_node_id, uint32 new_focused_node_id);
+  OnActiveWindowChanged(uint32 old_focused_window, uint32 new_focused_window);
 };
 
 }

mojo/services/window_manager/DEPS

@@ -3,6 +3,7 @@ include_rules = [
   "+mojo/service_manager",
   "+mojo/services/native_viewport",
   "+mojo/services/public",
+  "+ui/aura",
   "+ui/gfx",
   "+ui/gl",
   "+ui/wm",

mojo/services/window_manager/window_manager_api_unittest.cc

@@ -3,8 +3,14 @@
 // found in the LICENSE file.
 
 #include "base/bind.h"
+#include "base/memory/scoped_vector.h"
+#include "mojo/public/cpp/application/application_delegate.h"
+#include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/service_manager/service_manager.h"
+#include "mojo/services/public/cpp/view_manager/node.h"
 #include "mojo/services/public/cpp/view_manager/types.h"
+#include "mojo/services/public/cpp/view_manager/view_manager.h"
+#include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
 #include "mojo/services/public/interfaces/view_manager/view_manager.mojom.h"
 #include "mojo/services/public/interfaces/window_manager/window_manager.mojom.h"
 #include "mojo/shell/shell_test_helper.h"
@@ -13,6 +19,10 @@
 namespace mojo {
 namespace {
 
+const char kTestServiceURL[] = "mojo:test_url";
+
+void EmptyResultCallback(bool result) {}
+
 // Callback from EmbedRoot(). |result| is the result of the
 // Embed() call and |run_loop| the nested RunLoop.
 void ResultCallback(bool* result_cache, base::RunLoop* run_loop, bool result) {
@@ -48,12 +58,33 @@ view_manager::Id OpenWindow(WindowManagerService* window_manager) {
   return id;
 }
 
+view_manager::Id OpenWindowWithURL(WindowManagerService* window_manager,
+                                   const std::string& url) {
+  base::RunLoop run_loop;
+  view_manager::Id id;
+  window_manager->OpenWindowWithURL(
+      url,
+      base::Bind(&OpenWindowCallback, &id, &run_loop));
+  run_loop.Run();
+  return id;
+}
+
 class TestWindowManagerClient : public WindowManagerClient {
  public:
+  typedef base::Callback<void(view_manager::Id, view_manager::Id)>
+      TwoNodeCallback;
+
   explicit TestWindowManagerClient(base::RunLoop* run_loop)
       : run_loop_(run_loop) {}
   virtual ~TestWindowManagerClient() {}
 
+  void set_focus_changed_callback(const TwoNodeCallback& callback) {
+    focus_changed_callback_ = callback;
+  }
+  void set_active_window_changed_callback(const TwoNodeCallback& callback) {
+    active_window_changed_callback_ = callback;
+  }
+
  private:
   // Overridden from WindowManagerClient:
   virtual void OnWindowManagerReady() MOJO_OVERRIDE {
@@ -61,13 +92,74 @@ class TestWindowManagerClient : public WindowManagerClient {
   }
   virtual void OnCaptureChanged(
       view_manager::Id old_capture_node_id,
-      view_manager::Id new_capture_node_id) MOJO_OVERRIDE {}
+      view_manager::Id new_capture_node_id) MOJO_OVERRIDE {
+  }
+  virtual void OnFocusChanged(
+      view_manager::Id old_focused_node_id,
+      view_manager::Id new_focused_node_id) MOJO_OVERRIDE {
+    if (!focus_changed_callback_.is_null())
+      focus_changed_callback_.Run(old_focused_node_id, new_focused_node_id);
+  }
+  virtual void OnActiveWindowChanged(
+      view_manager::Id old_active_window,
+      view_manager::Id new_active_window) MOJO_OVERRIDE {
+    if (!active_window_changed_callback_.is_null())
+      active_window_changed_callback_.Run(old_active_window, new_active_window);
+  }
 
   base::RunLoop* run_loop_;
+  TwoNodeCallback focus_changed_callback_;
+  TwoNodeCallback active_window_changed_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowManagerClient);
 };
 
+class TestServiceLoader : public ServiceLoader,
+                          public ApplicationDelegate,
+                          public view_manager::ViewManagerDelegate {
+ public:
+  typedef base::Callback<void(view_manager::Node*)> RootAddedCallback;
+
+  explicit TestServiceLoader(const RootAddedCallback& root_added_callback)
+      : root_added_callback_(root_added_callback) {}
+  virtual ~TestServiceLoader() {}
+
+ private:
+  // Overridden from ServiceLoader:
+  virtual void LoadService(ServiceManager* service_manager,
+                           const GURL& url,
+                           ScopedMessagePipeHandle shell_handle) MOJO_OVERRIDE {
+    scoped_ptr<ApplicationImpl> app(
+        new ApplicationImpl(this, shell_handle.Pass()));
+    apps_.push_back(app.release());
+  }
+  virtual void OnServiceError(ServiceManager* service_manager,
+                              const GURL& url) MOJO_OVERRIDE {
+  }
+
+  // Overridden from ApplicationDelegate:
+  virtual bool ConfigureIncomingConnection(
+      ApplicationConnection* connection) MOJO_OVERRIDE {
+    view_manager::ViewManager::ConfigureIncomingConnection(connection, this);
+    return true;
+  }
+
+  // Overridden from ViewManagerDelegate:
+  virtual void OnRootAdded(view_manager::ViewManager* view_manager,
+                           view_manager::Node* root) MOJO_OVERRIDE {
+    root_added_callback_.Run(root);
+  }
+  virtual void OnViewManagerDisconnected(
+      view_manager::ViewManager* view_manager) MOJO_OVERRIDE {
+  }
+
+  RootAddedCallback root_added_callback_;
+
+  ScopedVector<ApplicationImpl> apps_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestServiceLoader);
+};
+
 }  // namespace
 
 class WindowManagerApiTest : public testing::Test {
@@ -76,12 +168,52 @@ class WindowManagerApiTest : public testing::Test {
   virtual ~WindowManagerApiTest() {}
 
  protected:
+  typedef std::pair<view_manager::Id, view_manager::Id> TwoIds;
+
+  view_manager::Id WaitForEmbed() {
+    view_manager::Id id;
+    base::RunLoop run_loop;
+    root_added_callback_ = base::Bind(&WindowManagerApiTest::OnEmbed,
+                                      base::Unretained(this), &id, &run_loop);
+    run_loop.Run();
+    return id;
+  }
+
+  TwoIds WaitForFocusChange() {
+    TwoIds old_and_new;
+    base::RunLoop run_loop;
+    window_manager_client()->set_focus_changed_callback(
+        base::Bind(&WindowManagerApiTest::OnFocusChanged,
+                   base::Unretained(this), &old_and_new, &run_loop));
+    run_loop.Run();
+    return old_and_new;
+  }
+
+  TwoIds WaitForActiveWindowChange() {
+    TwoIds old_and_new;
+    base::RunLoop run_loop;
+    window_manager_client()->set_active_window_changed_callback(
+        base::Bind(&WindowManagerApiTest::OnActiveWindowChanged,
+                   base::Unretained(this), &old_and_new, &run_loop));
+    run_loop.Run();
+    return old_and_new;
+  }
+
+  TestWindowManagerClient* window_manager_client() {
+    return window_manager_client_.get();
+  }
+
   WindowManagerServicePtr window_manager_;
 
  private:
   // Overridden from testing::Test:
   virtual void SetUp() MOJO_OVERRIDE {
     test_helper_.Init();
+    test_helper_.SetLoaderForURL(
+        scoped_ptr<ServiceLoader>(new TestServiceLoader(
+            base::Bind(&WindowManagerApiTest::OnRootAdded,
+                       base::Unretained(this)))),
+        GURL(kTestServiceURL));
     test_helper_.service_manager()->ConnectToService(
         GURL("mojo:mojo_view_manager"),
         &view_manager_init_);
@@ -96,21 +228,74 @@ class WindowManagerApiTest : public testing::Test {
         GURL("mojo:mojo_core_window_manager"),
         &window_manager_);
     base::RunLoop connect_loop;
-    window_manager_client_ = new TestWindowManagerClient(&connect_loop);
-    window_manager_.set_client(window_manager_client_);
+    window_manager_client_.reset(new TestWindowManagerClient(&connect_loop));
+    window_manager_.set_client(window_manager_client());
     connect_loop.Run();
   }
 
+  void OnRootAdded(view_manager::Node* root) {
+    if (!root_added_callback_.is_null())
+      root_added_callback_.Run(root);
+  }
+
+  void OnEmbed(view_manager::Id* root_id,
+               base::RunLoop* loop,
+               view_manager::Node* root) {
+    *root_id = root->id();
+    loop->Quit();
+  }
+
+  void OnFocusChanged(TwoIds* old_and_new,
+                      base::RunLoop* run_loop,
+                      view_manager::Id old_focused_node_id,
+                      view_manager::Id new_focused_node_id) {
+    DCHECK(old_and_new);
+    old_and_new->first = old_focused_node_id;
+    old_and_new->second = new_focused_node_id;
+    run_loop->Quit();
+  }
+
+  void OnActiveWindowChanged(TwoIds* old_and_new,
+                             base::RunLoop* run_loop,
+                             view_manager::Id old_focused_node_id,
+                             view_manager::Id new_focused_node_id) {
+    DCHECK(old_and_new);
+    old_and_new->first = old_focused_node_id;
+    old_and_new->second = new_focused_node_id;
+    run_loop->Quit();
+  }
+
   base::MessageLoop loop_;
   shell::ShellTestHelper test_helper_;
   view_manager::ViewManagerInitServicePtr view_manager_init_;
-  TestWindowManagerClient* window_manager_client_;
+  scoped_ptr<TestWindowManagerClient> window_manager_client_;
+  TestServiceLoader::RootAddedCallback root_added_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerApiTest);
 };
 
 TEST_F(WindowManagerApiTest, OpenWindow) {
   OpenWindow(window_manager_.get());
+  view_manager::Id created_node =
+      OpenWindowWithURL(window_manager_.get(), kTestServiceURL);
+  view_manager::Id embed_node = WaitForEmbed();
+  EXPECT_EQ(created_node, embed_node);
+}
+
+TEST_F(WindowManagerApiTest, FocusAndActivateWindow) {
+  view_manager::Id first_window = OpenWindow(window_manager_.get());
+  window_manager_->FocusWindow(first_window,
+                               base::Bind(&EmptyResultCallback));
+  TwoIds ids = WaitForFocusChange();
+  EXPECT_TRUE(ids.first == 0);
+  EXPECT_EQ(ids.second, first_window);
+
+  view_manager::Id second_window = OpenWindow(window_manager_.get());
+  window_manager_->ActivateWindow(second_window,
+                                  base::Bind(&EmptyResultCallback));
+  ids = WaitForActiveWindowChange();
+  EXPECT_EQ(ids.first, first_window);
+  EXPECT_EQ(ids.second, second_window);
 }
 
 }  // namespace mojo

mojo/services/window_manager/window_manager_app.cc

@@ -5,21 +5,82 @@
 #include "mojo/services/window_manager/window_manager_app.h"
 
 #include "base/message_loop/message_loop.h"
+#include "base/stl_util.h"
 #include "mojo/aura/aura_init.h"
 #include "mojo/aura/window_tree_host_mojo.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/services/public/cpp/view_manager/node.h"
 #include "mojo/services/public/cpp/view_manager/view_manager.h"
 #include "mojo/services/window_manager/window_manager_service_impl.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_property.h"
 #include "ui/wm/core/capture_controller.h"
+#include "ui/wm/core/focus_controller.h"
+#include "ui/wm/core/focus_rules.h"
+#include "ui/wm/public/activation_client.h"
+
+DECLARE_WINDOW_PROPERTY_TYPE(mojo::view_manager::Node*);
 
 namespace mojo {
+namespace {
+
+DEFINE_WINDOW_PROPERTY_KEY(view_manager::Node*, kNodeKey, NULL);
+
+view_manager::Id GetIdForWindow(aura::Window* window) {
+  return window ? window->GetProperty(kNodeKey)->id() : 0;
+}
+
+class WMFocusRules : public wm::FocusRules {
+ public:
+  WMFocusRules() {}
+  virtual ~WMFocusRules() {}
+
+ private:
+  // Overridden from wm::FocusRules:
+  virtual bool IsToplevelWindow(aura::Window* window) const MOJO_OVERRIDE {
+    return true;
+  }
+  virtual bool CanActivateWindow(aura::Window* window) const MOJO_OVERRIDE {
+    return true;
+  }
+  virtual bool CanFocusWindow(aura::Window* window) const MOJO_OVERRIDE {
+    return true;
+  }
+  virtual aura::Window* GetToplevelWindow(
+      aura::Window* window) const MOJO_OVERRIDE {
+    return window;
+  }
+  virtual aura::Window* GetActivatableWindow(
+      aura::Window* window) const MOJO_OVERRIDE {
+    return window;
+  }
+  virtual aura::Window* GetFocusableWindow(
+      aura::Window* window) const MOJO_OVERRIDE {
+    return window;
+  }
+  virtual aura::Window* GetNextActivatableWindow(
+      aura::Window* ignore) const MOJO_OVERRIDE {
+    return NULL;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(WMFocusRules);
+};
+
+}  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, public:
 
 WindowManagerApp::WindowManagerApp() : view_manager_(NULL), root_(NULL) {}
-WindowManagerApp::~WindowManagerApp() {}
+WindowManagerApp::~WindowManagerApp() {
+  // TODO(beng): Figure out if this should be done in
+  //             OnViewManagerDisconnected().
+  STLDeleteValues(&node_id_to_window_map_);
+  if (focus_client_.get())
+    focus_client_->RemoveObserver(this);
+  if (activation_client_)
+    activation_client_->RemoveObserver(this);
+}
 
 void WindowManagerApp::AddConnection(WindowManagerServiceImpl* connection) {
   DCHECK(connections_.find(connection) == connections_.end());
@@ -37,12 +98,31 @@ view_manager::Id WindowManagerApp::OpenWindow() {
   return node->id();
 }
 
+view_manager::Id WindowManagerApp::OpenWindowWithURL(const String& url) {
+  view_manager::Node* node = view_manager::Node::Create(view_manager_);
+  root_->AddChild(node);
+  node->Embed(url);
+  return node->id();
+}
+
 void WindowManagerApp::SetCapture(view_manager::Id node) {
   capture_client_->capture_client()->SetCapture(GetWindowForNodeId(node));
   // TODO(beng): notify connected clients that capture has changed, probably
   //             by implementing some capture-client observer.
 }
 
+void WindowManagerApp::FocusWindow(view_manager::Id node) {
+  aura::Window* window = GetWindowForNodeId(node);
+  DCHECK(window);
+  focus_client_->FocusWindow(window);
+}
+
+void WindowManagerApp::ActivateWindow(view_manager::Id node) {
+  aura::Window* window = GetWindowForNodeId(node);
+  DCHECK(window);
+  activation_client_->ActivateWindow(window);
+}
+
 bool WindowManagerApp::IsReady() const {
   return view_manager_ && root_;
 }
@@ -69,11 +149,21 @@ void WindowManagerApp::OnRootAdded(view_manager::ViewManager* view_manager,
   DCHECK(!view_manager_ && !root_);
   view_manager_ = view_manager;
   root_ = root;
+  root_->AddObserver(this);
 
   window_tree_host_.reset(new WindowTreeHostMojo(root_, this));
 
+  RegisterSubtree(root_->id(), window_tree_host_->window());
+
   capture_client_.reset(
       new wm::ScopedCaptureClient(window_tree_host_->window()));
+  wm::FocusController* focus_controller =
+      new wm::FocusController(new WMFocusRules);
+  activation_client_ = focus_controller;
+  focus_client_.reset(focus_controller);
+
+  focus_client_->AddObserver(this);
+  activation_client_->AddObserver(this);
 
   // TODO(beng): Create the universe.
 
@@ -86,10 +176,35 @@ void WindowManagerApp::OnRootAdded(view_manager::ViewManager* view_manager,
 void WindowManagerApp::OnViewManagerDisconnected(
     view_manager::ViewManager* view_manager) {
   DCHECK_EQ(view_manager_, view_manager);
+  root_->RemoveObserver(this);
+  root_ = NULL;
   view_manager_ = NULL;
   base::MessageLoop::current()->Quit();
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// WindowManagerApp, view_manager::NodeObserver implementation:
+
+void WindowManagerApp::OnTreeChanged(
+    const view_manager::NodeObserver::TreeChangeParams& params) {
+  DCHECK_EQ(params.receiver, root_);
+  DCHECK(params.old_parent || params.new_parent);
+  if (!params.target)
+    return;
+
+  if (params.new_parent) {
+    if (node_id_to_window_map_.find(params.target->id()) ==
+        node_id_to_window_map_.end()) {
+      NodeIdToWindowMap::const_iterator it =
+          node_id_to_window_map_.find(params.new_parent->id());
+      DCHECK(it != node_id_to_window_map_.end());
+      RegisterSubtree(params.target->id(), it->second);
+    }
+  } else if (params.old_parent) {
+    UnregisterSubtree(params.target->id());
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, WindowTreeHostMojoDelegate implementation:
 
@@ -98,13 +213,61 @@ void WindowManagerApp::CompositorContentsChanged(const SkBitmap& bitmap) {
   NOTREACHED();
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// WindowManagerApp, aura::client::FocusChangeObserver implementation:
+
+void WindowManagerApp::OnWindowFocused(aura::Window* gained_focus,
+                                       aura::Window* lost_focus) {
+  for (Connections::const_iterator it = connections_.begin();
+       it != connections_.end(); ++it) {
+    (*it)->NotifyNodeFocused(GetIdForWindow(gained_focus),
+                             GetIdForWindow(lost_focus));
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// WindowManagerApp, aura::client::ActivationChangeObserver implementation:
+
+void WindowManagerApp::OnWindowActivated(aura::Window* gained_active,
+                                         aura::Window* lost_active) {
+  for (Connections::const_iterator it = connections_.begin();
+       it != connections_.end(); ++it) {
+    (*it)->NotifyWindowActivated(GetIdForWindow(gained_active),
+                                 GetIdForWindow(lost_active));
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, private:
 
 aura::Window* WindowManagerApp::GetWindowForNodeId(
     view_manager::Id node) const {
-  NOTIMPLEMENTED();
-  return NULL;
+  NodeIdToWindowMap::const_iterator it = node_id_to_window_map_.find(node);
+  return it != node_id_to_window_map_.end() ? it->second : NULL;
+}
+
+void WindowManagerApp::RegisterSubtree(view_manager::Id id,
+                                       aura::Window* parent) {
+  view_manager::Node* node = view_manager_->GetNodeById(id);
+  DCHECK(node_id_to_window_map_.find(id) == node_id_to_window_map_.end());
+  aura::Window* window = new aura::Window(NULL);
+  window->SetProperty(kNodeKey, node);
+  parent->AddChild(window);
+  node_id_to_window_map_[id] = window;
+  view_manager::Node::Children::const_iterator it = node->children().begin();
+  for (; it != node->children().end(); ++it)
+    RegisterSubtree((*it)->id(), window);
+}
+
+void WindowManagerApp::UnregisterSubtree(view_manager::Id id) {
+  view_manager::Node* node = view_manager_->GetNodeById(id);
+  NodeIdToWindowMap::const_iterator it = node_id_to_window_map_.find(id);
+  DCHECK(it != node_id_to_window_map_.end());
+  scoped_ptr<aura::Window> window(it->second);
+  node_id_to_window_map_.erase(it);
+  view_manager::Node::Children::const_iterator child = node->children().begin();
+  for (; child != node->children().end(); ++child)
+    UnregisterSubtree((*child)->id());
 }
 
 ////////////////////////////////////////////////////////////////////////////////

mojo/services/window_manager/window_manager_app.h

@@ -10,10 +10,18 @@
 #include "base/memory/scoped_ptr.h"
 #include "mojo/aura/window_tree_host_mojo_delegate.h"
 #include "mojo/public/cpp/application/application_delegate.h"
+#include "mojo/public/cpp/bindings/string.h"
+#include "mojo/services/public/cpp/view_manager/node_observer.h"
 #include "mojo/services/public/cpp/view_manager/types.h"
 #include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
+#include "ui/aura/client/focus_change_observer.h"
+#include "ui/wm/public/activation_change_observer.h"
 
 namespace aura {
+namespace client {
+class ActivationClient;
+class FocusClient;
+}
 class Window;
 }
 
@@ -29,7 +37,10 @@ class WindowTreeHostMojo;
 
 class WindowManagerApp : public ApplicationDelegate,
                          public view_manager::ViewManagerDelegate,
-                         public WindowTreeHostMojoDelegate {
+                         public view_manager::NodeObserver,
+                         public WindowTreeHostMojoDelegate,
+                         public aura::client::FocusChangeObserver,
+                         public aura::client::ActivationChangeObserver {
  public:
   WindowManagerApp();
   virtual ~WindowManagerApp();
@@ -38,12 +49,16 @@ class WindowManagerApp : public ApplicationDelegate,
   void RemoveConnection(WindowManagerServiceImpl* connection);
 
   view_manager::Id OpenWindow();
+  view_manager::Id OpenWindowWithURL(const String& url);
   void SetCapture(view_manager::Id node);
+  void FocusWindow(view_manager::Id node);
+  void ActivateWindow(view_manager::Id node);
 
   bool IsReady() const;
 
  private:
   typedef std::set<WindowManagerServiceImpl*> Connections;
+  typedef std::map<view_manager::Id, aura::Window*> NodeIdToWindowMap;
 
   // Overridden from ApplicationDelegate:
   virtual void Initialize(ApplicationImpl* impl) MOJO_OVERRIDE;
@@ -56,11 +71,32 @@ class WindowManagerApp : public ApplicationDelegate,
   virtual void OnViewManagerDisconnected(
       view_manager::ViewManager* view_manager) MOJO_OVERRIDE;
 
+  // Overridden from view_manager::NodeObserver:
+  virtual void OnTreeChanged(
+      const view_manager::NodeObserver::TreeChangeParams& params) MOJO_OVERRIDE;
+
   // Overridden from WindowTreeHostMojoDelegate:
   virtual void CompositorContentsChanged(const SkBitmap& bitmap) MOJO_OVERRIDE;
 
+  // Overridden from aura::client::FocusChangeObserver:
+  virtual void OnWindowFocused(aura::Window* gained_focus,
+                               aura::Window* lost_focus) MOJO_OVERRIDE;
+
+  // Overridden from aura::client::ActivationChangeObserver:
+  virtual void OnWindowActivated(aura::Window* gained_active,
+                                 aura::Window* lost_active) MOJO_OVERRIDE;
+
   aura::Window* GetWindowForNodeId(view_manager::Id node) const;
 
+  // Creates an aura::Window for every node in the hierarchy beneath |id|,
+  // and adds to the registry so that it can be retrieved later via
+  // GetWindowForNodeId().
+  // TODO(beng): perhaps Node should have a property bag.
+  void RegisterSubtree(view_manager::Id id, aura::Window* parent);
+  // Deletes the aura::Windows associated with the hierarchy beneath |id|,
+  // and removes from the registry.
+  void UnregisterSubtree(view_manager::Id id);
+
   view_manager::ViewManager* view_manager_;
   view_manager::Node* root_;
 
@@ -68,8 +104,11 @@ class WindowManagerApp : public ApplicationDelegate,
   scoped_ptr<WindowTreeHostMojo> window_tree_host_;
 
   scoped_ptr<wm::ScopedCaptureClient> capture_client_;
+  scoped_ptr<aura::client::FocusClient> focus_client_;
+  aura::client::ActivationClient* activation_client_;
 
   Connections connections_;
+  NodeIdToWindowMap node_id_to_window_map_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerApp);
 };

mojo/services/window_manager/window_manager_service_impl.cc

@@ -26,20 +26,71 @@ void WindowManagerServiceImpl::NotifyReady() {
   client()->OnWindowManagerReady();
 }
 
+void WindowManagerServiceImpl::NotifyNodeFocused(
+    view_manager::Id new_focused_id,
+    view_manager::Id old_focused_id) {
+  client()->OnFocusChanged(old_focused_id, new_focused_id);
+}
+
+void WindowManagerServiceImpl::NotifyWindowActivated(
+    view_manager::Id new_active_id,
+    view_manager::Id old_active_id) {
+  client()->OnActiveWindowChanged(old_active_id, new_active_id);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerServiceImpl, WindowManager implementation:
 
 void WindowManagerServiceImpl::OpenWindow(
     const Callback<void(view_manager::Id)>& callback) {
-  view_manager::Id id = window_manager_->OpenWindow();
-  callback.Run(id);
+  bool success = window_manager_->IsReady();
+  if (success) {
+    view_manager::Id id = window_manager_->OpenWindow();
+    callback.Run(id);
+  } else {
+    // TODO(beng): perhaps should take an error code for this.
+    callback.Run(0);
+  }
+}
+
+void WindowManagerServiceImpl::OpenWindowWithURL(
+    const String& url,
+    const Callback<void(view_manager::Id)>& callback) {
+  bool success = window_manager_->IsReady();
+  if (success) {
+    view_manager::Id id = window_manager_->OpenWindowWithURL(url);
+    callback.Run(id);
+  } else {
+    // TODO(beng): perhaps should take an error code for this.
+    callback.Run(0);
+  }
 }
 
 void WindowManagerServiceImpl::SetCapture(
     view_manager::Id node,
     const Callback<void(bool)>& callback) {
-  window_manager_->SetCapture(node);
-  callback.Run(true);
+  bool success = window_manager_->IsReady();
+  if (success)
+    window_manager_->SetCapture(node);
+  callback.Run(success);
+}
+
+void WindowManagerServiceImpl::FocusWindow(
+    view_manager::Id node,
+    const Callback<void(bool)>& callback) {
+  bool success = window_manager_->IsReady();
+  if (success)
+    window_manager_->FocusWindow(node);
+  callback.Run(success);
+}
+
+void WindowManagerServiceImpl::ActivateWindow(
+    view_manager::Id node,
+    const Callback<void(bool)>& callback) {
+  bool success = window_manager_->IsReady();
+  if (success)
+    window_manager_->ActivateWindow(node);
+  callback.Run(success);
 }
 
 ////////////////////////////////////////////////////////////////////////////////

mojo/services/window_manager/window_manager_service_impl.h

@@ -21,13 +21,25 @@ class WindowManagerServiceImpl : public InterfaceImpl<WindowManagerService> {
   virtual ~WindowManagerServiceImpl();
 
   void NotifyReady();
+  void NotifyNodeFocused(view_manager::Id new_focused_id,
+                         view_manager::Id old_focused_id);
+  void NotifyWindowActivated(view_manager::Id new_active_id,
+                             view_manager::Id old_active_id);
 
  private:
   // Overridden from WindowManagerService:
   virtual void OpenWindow(
       const Callback<void(view_manager::Id)>& callback) MOJO_OVERRIDE;
+  virtual void OpenWindowWithURL(
+      const String& url,
+      const Callback<void(view_manager::Id)>& callback) MOJO_OVERRIDE;
   virtual void SetCapture(view_manager::Id node,
                           const Callback<void(bool)>& callback) MOJO_OVERRIDE;
+  virtual void FocusWindow(view_manager::Id node,
+                           const Callback<void(bool)>& callback) MOJO_OVERRIDE;
+  virtual void ActivateWindow(
+      view_manager::Id node,
+      const Callback<void(bool)>& callback) MOJO_OVERRIDE;
 
   // Overridden from InterfaceImpl:
   virtual void OnConnectionEstablished() MOJO_OVERRIDE;