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/common/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 223 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 {

[Jun Mukai, 2014/09/10 00:07:10]

Rather than bundling terminating callbacks here, it would be better to introduce
observer events (AthenaEnvObserver / OnAthenaTerminating()) and let each
AppDelegate observe the event to run the callback on terminating.

[oshima, 2014/09/10 00:47:49]

I'd like to use callback for a couple of reasons.

1) There was a thread in chromium-dev about this, and there, a lot of people
preferred callback as a way to replace NotificationService.
2) I want to avoid having too many observers, or one observer that observes
everything.
3) It makes it a bit easier to integrate components and chrome code. Callback is
in
  base/ while observer has to be in athena/.

Reference:

https://groups.google.com/a/chromium.org/forum/#!searchin/chromium-dev/$20sin...

http://www.chromium.org/developers/content-module/content-api

[Jun Mukai, 2014/09/10 00:51:48]

Okay, in that case.

I imagine that this type of thing (implementing set of callbacks) could be in
base/ rather than here, but that could be done in another CL.

+    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();

[Jun Mukai, 2014/09/10 00:24:30]

iter->Run();

[oshima, 2014/09/10 00:47:50]

Done.

+    }
+  }
+
   // 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 41 matching lines @@
 
 // static
 
 // static
 void AthenaEnv::Shutdown() {
   DCHECK(instance);
   delete instance;
 }
 
 }  // namespace athena