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

mojo/services/window_manager/window_manager_app.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/window_manager/window_manager_app.h"
 
 #include "base/message_loop/message_loop.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() {}

[sky, 2014/07/17 23:15:42]

Do you need to delete windows in node_id_to_window_map_ here?

 
 void WindowManagerApp::AddConnection(WindowManagerServiceImpl* connection) {
   DCHECK(connections_.find(connection) == connections_.end());
   connections_.insert(connection);
 }
 
 void WindowManagerApp::RemoveConnection(WindowManagerServiceImpl* connection) {
   DCHECK(connections_.find(connection) != connections_.end());
   connections_.erase(connection);
 }
 
 view_manager::Id WindowManagerApp::OpenWindow() {
   view_manager::Node* node = view_manager::Node::Create(view_manager_);
   root_->AddChild(node);

[sky, 2014/07/17 23:15:42]

Are you guaranteed to have a root_ by the time you get this?

[Ben Goodger (Google), 2014/07/18 19:50:44]

No. In practice the test waits for IsReady(), but I don't actually block these
calls. I've changed these methods to return failure thru the callback.

   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_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ApplicationDelegate implementation:
 
 void WindowManagerApp::Initialize(ApplicationImpl* impl) {
   aura_init_.reset(new AuraInit);
 }
 
 bool WindowManagerApp::ConfigureIncomingConnection(
     ApplicationConnection* connection) {
   connection->AddService<WindowManagerServiceImpl>(this);
   view_manager::ViewManager::ConfigureIncomingConnection(connection, this);
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, view_manager::ViewManagerDelegate implementation:
 
 void WindowManagerApp::OnRootAdded(view_manager::ViewManager* view_manager,
                                    view_manager::Node* root) {
   DCHECK(!view_manager_ && !root_);
   view_manager_ = view_manager;
   root_ = root;
+  root_->AddObserver(this);

[sky, 2014/07/17 23:15:42]

Do you need to remove this in the destructor if non-null?

 
   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);

[sky, 2014/07/17 23:15:42]

Remove these observers?

+  activation_client_->AddObserver(this);
 
   // TODO(beng): Create the universe.
 
   for (Connections::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     (*it)->NotifyReady();
   }
 }
 
 void WindowManagerApp::OnViewManagerDisconnected(
     view_manager::ViewManager* view_manager) {
   DCHECK_EQ(view_manager_, view_manager);
   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());
+  }
+}
+
+void WindowManagerApp::OnNodeDestroyed(view_manager::Node* node) {
+  DCHECK_EQ(root_, node);
+  root_->RemoveObserver(this);
+  root_ = NULL;
+}

[sky, 2014/07/17 23:15:42]

Do you need to UnregisterSubstree here? If not, who cleans up
node_id_to_window_map_?

[Ben Goodger (Google), 2014/07/18 19:50:44]

I removed this method. It's actually never called for this app as the view
manager doesn't destroy the root node until after it is disconnected from the
app embedded at it.

The windows that live in the node id to window map are freed in the dtor now.

+
+////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, WindowTreeHostMojoDelegate implementation:
 
 void WindowManagerApp::CompositorContentsChanged(const SkBitmap& bitmap) {
   // We draw nothing.
   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());
+  aura::Window* window = it->second;

[sky, 2014/07/17 23:15:42]

put in scoped_ptr so you don't need delete on 266.

+  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());
+  delete window;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ApplicationDelegate, public:
 
 // static
 ApplicationDelegate* ApplicationDelegate::Create() {
   return new WindowManagerApp;
 }
 
 }  // namespace mojo