Adds capture to the mojo window_manager.

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 "services/window_manager/window_manager_app.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
 #include "mojo/services/view_manager/public/cpp/view.h"
 #include "mojo/services/view_manager/public/cpp/view_manager.h"
+#include "services/window_manager/capture_controller.h"
 #include "services/window_manager/focus_controller.h"
 #include "services/window_manager/focus_rules.h"
 #include "services/window_manager/view_event_dispatcher.h"
 #include "services/window_manager/view_target.h"
 #include "services/window_manager/view_targeter.h"
 #include "services/window_manager/window_manager_delegate.h"
 #include "ui/base/hit_test.h"
 
 using mojo::ApplicationConnection;
 using mojo::Id;
@@ skipping 39 matching lines @@
 void WindowManagerApp::AddConnection(WindowManagerImpl* connection) {
   DCHECK(connections_.find(connection) == connections_.end());
   connections_.insert(connection);
 }
 
 void WindowManagerApp::RemoveConnection(WindowManagerImpl* connection) {
   DCHECK(connections_.find(connection) != connections_.end());
   connections_.erase(connection);
 }
 
-void WindowManagerApp::SetCapture(Id view) {
-  // TODO(erg): Capture. Another pile of worms that is mixed in here.
-
-  // capture_client_->capture_client()->SetCapture(GetWindowForViewId(view));
-
-  // TODO(beng): notify connected clients that capture has changed, probably
-  //             by implementing some capture-client observer.
+void WindowManagerApp::SetCapture(Id view_id) {
+  View* view = view_manager_->GetViewById(view_id);
+  DCHECK(view);
+  capture_controller_->SetCapture(view);
 }
 
 void WindowManagerApp::FocusWindow(Id view_id) {
   View* view = view_manager_->GetViewById(view_id);
   DCHECK(view);
   focus_controller_->FocusView(view);
 }
 
 void WindowManagerApp::ActivateWindow(Id view_id) {
   View* view = view_manager_->GetViewById(view_id);
   DCHECK(view);
   focus_controller_->ActivateView(view);
 }
 
 bool WindowManagerApp::IsReady() const {
   return view_manager_ && root_;
 }
 
 void WindowManagerApp::InitFocus(scoped_ptr<FocusRules> rules) {
+  DCHECK(root_);
+
   focus_controller_.reset(new FocusController(rules.Pass()));
   focus_controller_->AddObserver(this);
+  SetFocusController(root_, focus_controller_.get());
 
-  DCHECK(root_);
-  SetFocusController(root_, focus_controller_.get());
+  capture_controller_.reset(new CaptureController);
+  capture_controller_->AddObserver(this);
+  SetCaptureController(root_, capture_controller_.get());
 }
 
 void WindowManagerApp::Embed(
     const mojo::String& url,
     mojo::InterfaceRequest<ServiceProvider> service_provider) {
   if (view_manager_) {
     window_manager_delegate_->Embed(url, service_provider.Pass());
     return;
   }
   scoped_ptr<PendingEmbed> pending_embed(new PendingEmbed);
@@ skipping 24 matching lines @@
                                mojo::ServiceProviderImpl* exported_services,
                                scoped_ptr<ServiceProvider> imported_services) {
   DCHECK(!view_manager_ && !root_);
   view_manager_ = view_manager;
   root_ = root;
 
   view_event_dispatcher_.reset(new ViewEventDispatcher);
 
   RegisterSubtree(root_);
 
-  // TODO(erg): Also move the capture client over.
-  //
-  // capture_client_.reset(
-  //     new wm::ScopedCaptureClient(window_tree_host_->window()));
-
   if (wrapped_view_manager_delegate_) {
     wrapped_view_manager_delegate_->OnEmbed(
         view_manager, root, exported_services, imported_services.Pass());
   }
 
   for (PendingEmbed* pending_embed : pending_embeds_)
     Embed(pending_embed->url, pending_embed->service_provider.Pass());
   pending_embeds_.clear();
 }
 
@@ skipping 31 matching lines @@
 }
 
 void WindowManagerApp::OnViewDestroying(View* view) {
   if (view != root_) {
     Unregister(view);
     return;
   }
   root_ = nullptr;
   if (focus_controller_)
     focus_controller_->RemoveObserver(this);
+  if (capture_controller_)
+    capture_controller_->RemoveObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ui::EventHandler implementation:
 
 void WindowManagerApp::OnEvent(ui::Event* event) {
   if (!window_manager_client_)
     return;
 
   View* view = static_cast<ViewTarget*>(event->target())->view();
@@ skipping 24 matching lines @@
   for (Connections::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     (*it)->NotifyWindowActivated(GetIdForView(gained_active),
                                  GetIdForView(lost_active));
   }
   if (gained_active)
     gained_active->MoveToFront();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// WindowManagerApp, mojo::CaptureControllerObserver implementation:
+
+void WindowManagerApp::OnCaptureChanged(View* gained_capture,
+                                        View* lost_capture) {
+  for (Connections::const_iterator it = connections_.begin();
+       it != connections_.end(); ++it) {
+    (*it)->NotifyCaptureChanged(GetIdForView(gained_capture),
+                                GetIdForView(lost_capture));
+  }
+  if (gained_capture)
+    gained_capture->MoveToFront();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, private:
 
 void WindowManagerApp::RegisterSubtree(View* view) {
   view->AddObserver(this);
   DCHECK(registered_view_id_set_.find(view->id()) ==
          registered_view_id_set_.end());
   // All events pass through the root during dispatch, so we only need a handler
   // installed there.
   if (view == root_) {
     ViewTarget* target = ViewTarget::TargetFromView(view);
@@ skipping 81 matching lines @@
     uint16_t connection_id,
     mojo::ScopedMessagePipeHandle window_manager_pipe) {
   // TODO(sky): pass in |connection_id| for validation.
   WindowManagerImpl* wm = new WindowManagerImpl(this, true);
   wm->Bind(window_manager_pipe.Pass());
   // WindowManagerImpl is deleted when the connection has an error, or from our
   // destructor.
 }
 
 }  // namespace window_manager