Supprot V2 app: step1

athena/env/athena_env_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 "athena/env/public/athena_env.h"
 
+#include <vector>
+
 #include "athena/util/fill_layout_manager.h"
 #include "base/sys_info.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/test_screen.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/aura/window_tree_host_observer.h"
@@ skipping 225 matching lines @@
 
     ScreenForShutdown::Create(screen_.get());
     screen_.reset();
     aura::Env::DeleteInstance();
 
     display_configurator_->RemoveObserver(this);
     display_configurator_.reset();
   }
 
  private:
+  struct Finder {
+    explicit Finder(const base::Closure& c) : closure(c) {}
+    bool operator()(const base::Closure& other) {
+      return closure.Equals(other);
+    }
+    base::Closure closure;
+  };
+
+  // AthenaEnv:
   virtual aura::WindowTreeHost* GetHost() OVERRIDE { return host_.get(); }
 
-  // AthenaEnv:
   virtual void SetDisplayWorkAreaInsets(const gfx::Insets& insets) OVERRIDE {
     screen_->SetWorkAreaInsets(insets);
   }
 
+  virtual void AddTerminatingCallback(const base::Closure& closure) OVERRIDE {
+    if (closure.is_null())
+      return;
+    DCHECK(terminating_callbacks_.end() ==
+           std::find_if(terminating_callbacks_.begin(),
+                        terminating_callbacks_.end(),
+                        Finder(closure)));
+    terminating_callbacks_.push_back(closure);
+  }
+
+  virtual void RemoveTerminatingCallback(
+      const base::Closure& closure) OVERRIDE {
+    std::vector<base::Closure>::iterator iter =
+        std::find_if(terminating_callbacks_.begin(),
+                     terminating_callbacks_.end(),
+                     Finder(closure));
+    if (iter != terminating_callbacks_.end())
+      terminating_callbacks_.erase(iter);
+  }
+
+  virtual void OnTerminating() OVERRIDE {
+    for (std::vector<base::Closure>::iterator iter =
+             terminating_callbacks_.begin();
+         iter != terminating_callbacks_.end();
+         ++iter) {
+      iter->Run();
+    }
+  }
+
   // ui::DisplayConfigurator::Observer:
   virtual void OnDisplayModeChanged(const std::vector<
       ui::DisplayConfigurator::DisplayState>& displays) OVERRIDE {
     gfx::Size size = GetPrimaryDisplaySize();
     if (!size.IsEmpty())
       host_->UpdateRootWindowSize(size);
   }
 
   // aura::WindowTreeHostObserver:
   virtual void OnHostCloseRequested(const aura::WindowTreeHost* host) OVERRIDE {
@@ skipping 14 matching lines @@
   scoped_ptr<aura::WindowTreeHost> host_;
 
   scoped_ptr<wm::InputMethodEventFilter> input_method_filter_;
   scoped_ptr<wm::CompoundEventFilter> root_window_event_filter_;
   scoped_ptr<aura::client::DefaultCaptureClient> capture_client_;
   scoped_ptr<wm::CursorManager> cursor_manager_;
   scoped_ptr<wm::UserActivityDetector> user_activity_detector_;
   scoped_ptr<ui::DisplayConfigurator> display_configurator_;
   scoped_ptr<ui::UserActivityPowerManagerNotifier> user_activity_notifier_;
 
+  std::vector<base::Closure> terminating_callbacks_;
+
   DISALLOW_COPY_AND_ASSIGN(AthenaEnvImpl);
 };
 
 }  // namespace
 
 // static
 void AthenaEnv::Create() {
   DCHECK(!instance);
   new AthenaEnvImpl();
 }
 
 AthenaEnv* AthenaEnv::Get() {
   DCHECK(instance);
   return instance;
 }
 
 // static
 
 // static
 void AthenaEnv::Shutdown() {
   DCHECK(instance);
   delete instance;
 }
 
 }  // namespace athena