Move focus from the view manager to the window manager.

mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.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/public/cpp/view_manager/lib/view_manager_client_impl.h"
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_private.h"
 #include "mojo/services/public/cpp/view_manager/util.h"
 #include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
 #include "mojo/services/public/cpp/view_manager/view_observer.h"
@@ skipping 91 matching lines @@
 
   result = MapBuffer(
       handle->get(), 0, size, memory, MOJO_MAP_BUFFER_FLAG_NONE);
   if (result != MOJO_RESULT_OK)
     return false;
   DCHECK(*memory);
 
   return true;
 }
 
-ViewManagerClientImpl::ViewManagerClientImpl(ViewManagerDelegate* delegate)
+ViewManagerClientImpl::ViewManagerClientImpl(
+    ViewManagerDelegate* delegate,
+    ApplicationConnection* app_connection)
     : connected_(false),
       connection_id_(0),
       next_id_(1),
       delegate_(delegate),
       window_manager_delegate_(NULL) {
+  // TODO(beng): Come up with a better way of establishing a configuration for
+  //             what the active window manager is.
+  std::string window_manager_url = "mojo:mojo_window_manager";
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch("window-manager")) {
+    window_manager_url =
+        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            "window-manager");
+  }
+  app_connection->ConnectToService(window_manager_url, &window_manager_);
+  window_manager_.set_client(this);
 }
 
 ViewManagerClientImpl::~ViewManagerClientImpl() {
   std::vector<View*> non_owned;
   while (!views_.empty()) {
     IdToViewMap::iterator it = views_.begin();
     if (OwnsView(it->second->id())) {
       it->second->Destroy();
     } else {
       non_owned.push_back(it->second);
@@ skipping 66 matching lines @@
     return;
 
   memcpy(memory, &data[0], data.size());
 
   service_->SetViewContents(view_id, duped.Pass(),
                             static_cast<uint32_t>(data.size()),
                             ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::SetFocus(Id view_id) {
-  DCHECK(connected_);
-  service_->SetFocus(view_id, ActionCompletedCallback());
+  window_manager_->FocusWindow(view_id, ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::SetVisible(Id view_id, bool visible) {
   DCHECK(connected_);
   service_->SetViewVisibility(view_id, visible, ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::Embed(const String& url, Id view_id) {
   ServiceProviderPtr sp;
   BindToProxy(new ServiceProviderImpl, &sp);
@@ skipping 19 matching lines @@
   if (it != views_.end())
     views_.erase(it);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, ViewManager implementation:
 
 void ViewManagerClientImpl::SetWindowManagerDelegate(
     WindowManagerDelegate* window_manager_delegate) {
   CHECK(NULL != GetViewById(1));
+  CHECK(!window_manager_delegate_);
   window_manager_delegate_ = window_manager_delegate;
 }
 
 void ViewManagerClientImpl::DispatchEvent(View* target, EventPtr event) {
   CHECK(window_manager_delegate_);
   service_->DispatchOnViewInputEvent(target->id(), event.Pass());
 }
 
 const std::string& ViewManagerClientImpl::GetEmbedderURL() const {
   return creator_url_;
@@ skipping 95 matching lines @@
     const Callback<void()>& ack_callback) {
   View* view = GetViewById(view_id);
   if (view) {
     FOR_EACH_OBSERVER(ViewObserver,
                       *ViewPrivate(view).observers(),
                       OnViewInputEvent(view, event));
   }
   ack_callback.Run();
 }
 
-void ViewManagerClientImpl::OnFocusChanged(Id gained_focus_id,
-                                           Id lost_focus_id) {
-  View* focused = GetViewById(gained_focus_id);
-  View* blurred = GetViewById(lost_focus_id);
+void ViewManagerClientImpl::Embed(
+    const String& url,
+    InterfaceRequest<ServiceProvider> service_provider) {
+  window_manager_delegate_->Embed(url, service_provider.Pass());
+}
+
+void ViewManagerClientImpl::DispatchOnViewInputEvent(EventPtr event) {
+  if (window_manager_delegate_)
+    window_manager_delegate_->DispatchEvent(event.Pass());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ViewManagerClientImpl, WindowManagerClient implementation:
+
+void ViewManagerClientImpl::OnWindowManagerReady() {}
+
+void ViewManagerClientImpl::OnCaptureChanged(Id old_capture_view_id,
+                                             Id new_capture_view_id) {}
+
+void ViewManagerClientImpl::OnFocusChanged(Id old_focused_view_id,
+                                           Id new_focused_view_id) {
+  View* focused = GetViewById(new_focused_view_id);
+  View* blurred = GetViewById(old_focused_view_id);
   if (blurred) {
     FOR_EACH_OBSERVER(ViewObserver,
                       *ViewPrivate(blurred).observers(),
                       OnViewFocusChanged(focused, blurred));
   }
   if (focused) {
     FOR_EACH_OBSERVER(ViewObserver,
                       *ViewPrivate(focused).observers(),
                       OnViewFocusChanged(focused, blurred));
   }
 }
 
-void ViewManagerClientImpl::Embed(
-    const String& url,
-    InterfaceRequest<ServiceProvider> service_provider) {
-  window_manager_delegate_->Embed(url, service_provider.Pass());
-}
-
-void ViewManagerClientImpl::DispatchOnViewInputEvent(Id view_id,
-                                                     EventPtr event) {
-  if (window_manager_delegate_)
-    window_manager_delegate_->DispatchEvent(GetViewById(view_id), event.Pass());
-}
+void ViewManagerClientImpl::OnActiveWindowChanged(Id old_focused_window,
+                                                  Id new_focused_window) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, private:
 
 void ViewManagerClientImpl::RemoveRoot(View* root) {
   std::vector<View*>::iterator it =
       std::find(roots_.begin(), roots_.end(), root);
   if (it != roots_.end())
     roots_.erase(it);
 }
@@ skipping 12 matching lines @@
                     base::Unretained(this));
 }
 
 base::Callback<void(ErrorCode)>
     ViewManagerClientImpl::ActionCompletedCallbackWithErrorCode() {
   return base::Bind(&ViewManagerClientImpl::OnActionCompletedWithErrorCode,
                     base::Unretained(this));
 }
 
 }  // namespace mojo