Update mojo sdk to rev 59145288bae55b0fce4276b017df6a1117bcf00f

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/public/cpp/view_manager/lib/view_manager_client_impl.h"
+#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"
 #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/public/interfaces/application/shell.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"
+#include "mojo/services/view_manager/public/cpp/lib/view_private.h"
+#include "mojo/services/view_manager/public/cpp/util.h"
+#include "mojo/services/view_manager/public/cpp/view_manager_delegate.h"
+#include "mojo/services/view_manager/public/cpp/view_observer.h"
 
 namespace mojo {
 
 Id MakeTransportId(ConnectionSpecificId connection_id,
                    ConnectionSpecificId local_id) {
   return (connection_id << 16) | local_id;
 }
 
 // Helper called to construct a local view object from transport data.
 View* AddViewToViewManager(ViewManagerClientImpl* client,
@@ skipping 45 matching lines @@
 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())->RemoveRoot(root_);
+        ViewPrivate(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),
+      focused_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())) {
@@ skipping 111 matching lines @@
     views_.erase(it);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, ViewManager implementation:
 
 const std::string& ViewManagerClientImpl::GetEmbedderURL() const {
   return creator_url_;
 }
 
-const std::vector<View*>& ViewManagerClientImpl::GetRoots() const {
-  return roots_;
+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_;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, ViewManagerClient implementation:
 
 void ViewManagerClientImpl::OnEmbed(
     ConnectionSpecificId connection_id,
     const String& creator_url,
     ViewDataPtr root_data,
     InterfaceRequest<ServiceProvider> parent_services,
     ScopedMessagePipeHandle window_manager_pipe) {
-  if (!connected_) {
-    connected_ = true;
-    connection_id_ = connection_id;
-    creator_url_ = String::From(creator_url);
-  } else {
-    DCHECK_EQ(connection_id_, connection_id);
-    DCHECK_EQ(creator_url_, creator_url);
-  }
+  DCHECK(!connected_);
+  connected_ = true;
+  connection_id_ = connection_id;
+  creator_url_ = String::From(creator_url);
 
-  // A new root must not already exist as a root or be contained by an existing
-  // hierarchy visible to this view manager.
-  View* root = AddViewToViewManager(this, NULL, root_data);
-  roots_.push_back(root);
-  root->AddObserver(new RootObserver(root));
+  DCHECK(!root_);
+  root_ = AddViewToViewManager(this, nullptr, root_data);
+  root_->AddObserver(new RootObserver(root_));
 
   ServiceProviderImpl* exported_services = nullptr;
   scoped_ptr<ServiceProvider> remote;
 
   if (parent_services.is_pending()) {
     // BindToRequest() binds the lifetime of |exported_services| to the pipe.
     exported_services = new ServiceProviderImpl;
     BindToRequest(exported_services, &parent_services);
     remote.reset(exported_services->CreateRemoteServiceProvider());
   }
   window_manager_.Bind(window_manager_pipe.Pass());
   window_manager_.set_client(this);
-  delegate_->OnEmbed(this, root, exported_services, remote.Pass());
+  // 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());
 }
 
 void ViewManagerClientImpl::OnEmbeddedAppDisconnected(Id view_id) {
   View* view = GetViewById(view_id);
   if (view) {
     FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(view).observers(),
                       OnViewEmbeddedAppDisconnected(view));
   }
 }
 
@@ skipping 91 matching lines @@
 
 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) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // OnConnectionError, private:
 void ViewManagerClientImpl::OnConnectionError() {
   if (delete_on_error_)
     delete this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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);
+void ViewManagerClientImpl::RootDestroyed(View* root) {
+  DCHECK_EQ(root, root_);
+  root_ = nullptr;
 }
 
 void ViewManagerClientImpl::OnActionCompleted(bool success) {
   if (!change_acked_callback_.is_null())
     change_acked_callback_.Run();
 }
 
 void ViewManagerClientImpl::OnActionCompletedWithErrorCode(ErrorCode code) {
   OnActionCompleted(code == ERROR_CODE_NONE);
 }
 
 base::Callback<void(bool)> ViewManagerClientImpl::ActionCompletedCallback() {
   return base::Bind(&ViewManagerClientImpl::OnActionCompleted,
                     base::Unretained(this));
 }
 
 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);
+}
+
 }  // namespace mojo