Update mojo sdk to rev cc531b32182099a5a034a99daff35ed5d38a61c8

mojo/services/view_manager/public/cpp/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/view_manager/public/cpp/lib/view_manager_client_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/public/cpp/application/application_impl.h"
@@ skipping 62 matching lines @@
 // destroyed.
 class RootObserver : public ViewObserver {
  public:
   explicit RootObserver(View* root) : root_(root) {}
   ~RootObserver() override {}
 
  private:
   // Overridden from ViewObserver:
   void OnViewDestroyed(View* view) override {
     DCHECK_EQ(view, root_);
-    static_cast<ViewManagerClientImpl*>(
-        ViewPrivate(root_).view_manager())->RootDestroyed(root_);
+    static_cast<ViewManagerClientImpl*>(root_->view_manager())
+        ->RootDestroyed(root_);
     view->RemoveObserver(this);
     delete this;
   }
 
   View* root_;
 
   DISALLOW_COPY_AND_ASSIGN(RootObserver);
 };
 
 ViewManagerClientImpl::ViewManagerClientImpl(ViewManagerDelegate* delegate,
                                              Shell* shell,
                                              ScopedMessagePipeHandle handle,
                                              bool delete_on_error)
     : connected_(false),
       connection_id_(0),
       next_id_(1),
       delegate_(delegate),
       root_(nullptr),
+      capture_view_(nullptr),
       focused_view_(nullptr),
+      activated_view_(nullptr),
       binding_(this, handle.Pass()),
       service_(binding_.client()),
       delete_on_error_(delete_on_error) {
 }
 
 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);
       views_.erase(it);
     }
   }
   // Delete the non-owned views last. In the typical case these are roots. The
   // exception is the window manager, which may know aboutother random views
   // that it doesn't own.
   // NOTE: we manually delete as we're a friend.
   for (size_t i = 0; i < non_owned.size(); ++i)
     delete non_owned[i];
 
   delegate_->OnViewManagerDisconnected(this);
 }
 
-Id ViewManagerClientImpl::CreateView() {
-  DCHECK(connected_);
-  const Id view_id = MakeTransportId(connection_id_, ++next_id_);
-  service_->CreateView(view_id, ActionCompletedCallbackWithErrorCode());
-  return view_id;
-}
-
 void ViewManagerClientImpl::DestroyView(Id view_id) {
   DCHECK(connected_);
   service_->DeleteView(view_id, ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::AddChild(Id child_id, Id parent_id) {
   DCHECK(connected_);
   service_->AddView(parent_id, child_id, ActionCompletedCallback());
 }
 
@@ skipping 74 matching lines @@
 
 void ViewManagerClientImpl::RemoveView(Id view_id) {
   IdToViewMap::iterator it = views_.find(view_id);
   if (it != views_.end())
     views_.erase(it);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, ViewManager implementation:
 
+Id ViewManagerClientImpl::CreateViewOnServer() {
+  DCHECK(connected_);
+  const Id view_id = MakeTransportId(connection_id_, ++next_id_);
+  service_->CreateView(view_id, ActionCompletedCallbackWithErrorCode());
+  return view_id;
+}
+
 const std::string& ViewManagerClientImpl::GetEmbedderURL() const {
   return creator_url_;
 }
 
 View* ViewManagerClientImpl::GetRoot() {
   return root_;
 }
 
 View* ViewManagerClientImpl::GetViewById(Id id) {
   IdToViewMap::const_iterator it = views_.find(id);
   return it != views_.end() ? it->second : NULL;
 }
 
 View* ViewManagerClientImpl::GetFocusedView() {
   return focused_view_;
 }
 
+View* ViewManagerClientImpl::CreateView() {
+  View* view = new View(this, CreateViewOnServer());
+  AddView(view);
+  return view;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, ViewManagerClient implementation:
 
 void ViewManagerClientImpl::OnEmbed(
     ConnectionSpecificId connection_id,
     const String& creator_url,
     ViewDataPtr root_data,
     InterfaceRequest<ServiceProvider> parent_services,
     ScopedMessagePipeHandle window_manager_pipe) {
   DCHECK(!connected_);
@@ skipping 14 matching lines @@
     BindToRequest(exported_services, &parent_services);
     remote.reset(exported_services->CreateRemoteServiceProvider());
   }
   window_manager_.Bind(window_manager_pipe.Pass());
   window_manager_.set_client(this);
   // base::Unretained() is safe here as |window_manager_| is bound to our
   // lifetime.
   window_manager_->GetFocusedAndActiveViews(
       base::Bind(&ViewManagerClientImpl::OnGotFocusedAndActiveViews,
                  base::Unretained(this)));
-  delegate_->OnEmbed(this, root_, exported_services, remote.Pass());
+  delegate_->OnEmbed(root_, exported_services, remote.Pass());
 }
 
 void ViewManagerClientImpl::OnEmbeddedAppDisconnected(Id view_id) {
   View* view = GetViewById(view_id);
   if (view) {
     FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(view).observers(),
                       OnViewEmbeddedAppDisconnected(view));
   }
 }
 
@@ skipping 80 matching lines @@
                       *ViewPrivate(view).observers(),
                       OnViewInputEvent(view, event));
   }
   ack_callback.Run();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, WindowManagerClient implementation:
 
 void ViewManagerClientImpl::OnCaptureChanged(Id old_capture_view_id,
-                                             Id new_capture_view_id) {}
+                                             Id new_capture_view_id) {
+  View* gained_capture = GetViewById(new_capture_view_id);
+  View* lost_capture = GetViewById(old_capture_view_id);
+  if (lost_capture) {
+    FOR_EACH_OBSERVER(ViewObserver,
+                      *ViewPrivate(lost_capture).observers(),
+                      OnViewFocusChanged(gained_capture, lost_capture));
+  }
+  capture_view_ = gained_capture;
+  if (gained_capture) {
+    FOR_EACH_OBSERVER(ViewObserver,
+                      *ViewPrivate(gained_capture).observers(),
+                      OnViewFocusChanged(gained_capture, lost_capture));
+  }
+}
 
 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));
   }
   focused_view_ = focused;
   if (focused) {
     FOR_EACH_OBSERVER(ViewObserver,
                       *ViewPrivate(focused).observers(),
                       OnViewFocusChanged(focused, blurred));
   }
 }
 
-void ViewManagerClientImpl::OnActiveWindowChanged(Id old_focused_window,
-                                                  Id new_focused_window) {}
+void ViewManagerClientImpl::OnActiveWindowChanged(Id old_active_view_id,
+                                                  Id new_active_view_id) {
+  View* activated = GetViewById(new_active_view_id);
+  View* deactivated = GetViewById(old_active_view_id);
+  if (deactivated) {
+    FOR_EACH_OBSERVER(ViewObserver,
+                      *ViewPrivate(deactivated).observers(),
+                      OnViewActivationChanged(activated, deactivated));
+  }
+  activated_view_ = activated;
+  if (activated) {
+    FOR_EACH_OBSERVER(ViewObserver,
+                      *ViewPrivate(activated).observers(),
+                      OnViewActivationChanged(activated, deactivated));
+  }
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // OnConnectionError, private:
 void ViewManagerClientImpl::OnConnectionError() {
   if (delete_on_error_)
     delete this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, private:
@@ skipping 20 matching lines @@
 base::Callback<void(ErrorCode)>
     ViewManagerClientImpl::ActionCompletedCallbackWithErrorCode() {
   return base::Bind(&ViewManagerClientImpl::OnActionCompletedWithErrorCode,
                     base::Unretained(this));
 }
 
 void ViewManagerClientImpl::OnGotFocusedAndActiveViews(uint32 focused_view_id,
                                                        uint32 active_view_id) {
   if (GetViewById(focused_view_id) != focused_view_)
     OnFocusChanged(focused_view_ ? focused_view_->id() : 0, focused_view_id);
+  if (GetViewById(active_view_id) != activated_view_) {
+    OnActiveWindowChanged(activated_view_ ? activated_view_->id() : 0,
+                          active_view_id);
+  }
 }
 
 }  // namespace mojo