Nukes ViewManager arg from ViewManagerDelegate::OnEmbed

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"
@@ skipping 37 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, public:
 
 WindowManagerApp::WindowManagerApp(
     ViewManagerDelegate* view_manager_delegate,
     WindowManagerDelegate* window_manager_delegate)
     : shell_(nullptr),
       native_viewport_event_dispatcher_factory_(this),
       wrapped_view_manager_delegate_(view_manager_delegate),
       window_manager_delegate_(window_manager_delegate),
-      view_manager_(nullptr),
       root_(nullptr) {
 }
 
 WindowManagerApp::~WindowManagerApp() {
   STLDeleteElements(&connections_);
 }
 
 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_id) {
-  View* view = view_manager_->GetViewById(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);
+  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);
+  View* view = view_manager()->GetViewById(view_id);
   DCHECK(view);
   focus_controller_->ActivateView(view);
 }
 
 bool WindowManagerApp::IsReady() const {
-  return view_manager_ && root_;
+  return 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());
 
   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_) {
+  if (view_manager()) {
     window_manager_delegate_->Embed(url, service_provider.Pass());
     return;
   }
   scoped_ptr<PendingEmbed> pending_embed(new PendingEmbed);
   pending_embed->url = url;
   pending_embed->service_provider = service_provider.Pass();
   pending_embeds_.push_back(pending_embed.release());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ApplicationDelegate implementation:
 
 void WindowManagerApp::Initialize(mojo::ApplicationImpl* impl) {
   shell_ = impl->shell();
   LaunchViewManager(impl);
 }
 
 bool WindowManagerApp::ConfigureIncomingConnection(
     ApplicationConnection* connection) {
   connection->AddService(static_cast<InterfaceFactory<WindowManager>*>(this));
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ViewManagerDelegate implementation:
 
-void WindowManagerApp::OnEmbed(mojo::ViewManager* view_manager,
-                               View* root,
+void WindowManagerApp::OnEmbed(View* root,
                                mojo::ServiceProviderImpl* exported_services,
                                scoped_ptr<ServiceProvider> imported_services) {
-  DCHECK(!view_manager_ && !root_);
-  view_manager_ = view_manager;
+  DCHECK(!root_);
   root_ = root;
 
   view_event_dispatcher_.reset(new ViewEventDispatcher);
 
   RegisterSubtree(root_);
 
   if (wrapped_view_manager_delegate_) {
-    wrapped_view_manager_delegate_->OnEmbed(
-        view_manager, root, exported_services, imported_services.Pass());
+    wrapped_view_manager_delegate_->OnEmbed(root, exported_services,
+                                            imported_services.Pass());
   }
 
   for (PendingEmbed* pending_embed : pending_embeds_)
     Embed(pending_embed->url, pending_embed->service_provider.Pass());
   pending_embeds_.clear();
 }
 
 void WindowManagerApp::OnViewManagerDisconnected(
     mojo::ViewManager* view_manager) {
-  DCHECK_EQ(view_manager_, view_manager);
+  DCHECK(this->view_manager());
+  DCHECK_EQ(this->view_manager(), view_manager);
   if (wrapped_view_manager_delegate_)
     wrapped_view_manager_delegate_->OnViewManagerDisconnected(view_manager);
-  view_manager_ = nullptr;
+  root_ = nullptr;
   base::MessageLoop::current()->Quit();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ViewObserver implementation:
 
 void WindowManagerApp::OnTreeChanged(
     const ViewObserver::TreeChangeParams& params) {
   if (params.receiver != root_)
     return;
@@ skipping 176 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