Migrate TabControlFeature from 0.5 to 0.6

blimp/client/core/contents/blimp_contents_manager.cc

+// Copyright 2016 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 "blimp/client/core/contents/blimp_contents_manager.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "blimp/client/public/contents/blimp_contents_observer.h"
+
+namespace {
+const int kDummyTabId = 0;
+}
+
+namespace blimp {
+namespace client {
+
+class BlimpContentsManager::BlimpContentsDeletionObserver
+    : public BlimpContentsObserver {
+ public:
+  BlimpContentsDeletionObserver(BlimpContentsManager* blimp_contents_manager,
+                                BlimpContentsImpl* blimp_contents,
+                                int id);
+  ~BlimpContentsDeletionObserver() override;
+
+  void OnContentsDestroyed() override;
+
+  BlimpContentsImpl* blimp_contents() { return contents_; }
+
+ private:
+  // The BlimpContentsManager containing this BlimpContentsDeletionObserver
+  BlimpContentsManager* blimp_contents_manager_;
+
+  // The BlimpContents being tracked by this BlimpContentsDeletionObserver.
+  BlimpContentsImpl* contents_;
+
+  // id of the BlimpContents created by BlimpContentsManager.
+  int id_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlimpContentsDeletionObserver);
+};
+
+BlimpContentsManager::BlimpContentsDeletionObserver::
+    BlimpContentsDeletionObserver(BlimpContentsManager* blimp_contents_manager,
+                                  BlimpContentsImpl* blimp_contents,

[David Trainor- moved to gerrit, 2016/08/03 18:55:42]

Can we just make BlimpContentsObserver take a BlimpContents in the constructor
and auto-clear it once it sees the destroy call?  That way we can just expose a
blimp_contents() method to access the BlimpContents and we can guarantee all
future observers will never point to a destroyed contents by accident.

[Menglin, 2016/08/03 19:25:48]

But BlimpContentsManager still needs to keep a map to hold all observers. So
when the content is destroyed, the observer needs to be destroyed from the map
as well. So it needs a BlimpContentsManager* as an input in the constructor.

or am i misunderstood your point?

[Menglin, 2016/08/03 23:49:59]

Yeah. BlimpContentsDeletionObserver doesn't need to take an id in the
constructor.

I think to keep BlimpContentsImpl* blimp_contents() within
BlimpContentsDeletionObserver is better. Reason, it needs to return a
BlimpContentsImpl* (instead of BlimpContent*) because the caller of
blimp_contents() may want to know the id() of the content, which is only
available in BlimpContentImpl. 

[David Trainor- moved to gerrit, 2016/08/04 16:21:18]

I think the problem is we're solving the observer -> contents lifecycle
dependency in a child class.  It would probably be cleaner to solve it in the
base class so all observers don't have to reimplement it.  I'd be fine with a
static_cast<BlimpContentsImpl*>(blimp_contents())->id() if we needed it.

wdyt?

[Menglin, 2016/08/05 02:08:24]

ok. got your point. yeah it makes sense to solve it in the base class

+                                  int id)
+    : blimp_contents_manager_(blimp_contents_manager),
+      contents_(blimp_contents),
+      id_(id) {
+  blimp_contents->AddObserver(this);
+}
+
+BlimpContentsManager::BlimpContentsDeletionObserver::
+    ~BlimpContentsDeletionObserver() {
+  if (contents_) {
+    contents_->RemoveObserver(this);
+  }
+}
+
+void BlimpContentsManager::BlimpContentsDeletionObserver::
+    OnContentsDestroyed() {
+  DCHECK(contents_);
+
+  contents_ = nullptr;
+  DCHECK(base::ThreadTaskRunnerHandle::Get());
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&BlimpContentsManager::EraseObserverFromMap,
+                            base::Unretained(blimp_contents_manager_), id_));
+}
+
+BlimpContentsManager::BlimpContentsManager() {}
+
+BlimpContentsManager::~BlimpContentsManager() {}
+
+std::unique_ptr<BlimpContentsImpl> BlimpContentsManager::CreateBlimpContents() {
+  int id = CreateBlimpContentsId();
+  std::unique_ptr<BlimpContentsImpl> new_contents =
+      base::WrapUnique(new BlimpContentsImpl(id));
+  std::unique_ptr<BlimpContentsDeletionObserver> observer = base::WrapUnique(
+      new BlimpContentsDeletionObserver(this, new_contents.get(), id));
+  observer_map_.insert(
+      std::pair<int, std::unique_ptr<BlimpContentsDeletionObserver>>(
+          id, std::move(observer)));
+  return new_contents;
+}
+
+BlimpContentsImpl* BlimpContentsManager::GetBlimpContents(int id) {
+  if (observer_map_.find(id) != observer_map_.end()) {
+    BlimpContentsDeletionObserver* observer = observer_map_.at(id).get();
+    // If the BlimpContents that the observer tracks is empty, it means
+    // OnContentsDestroyed was called on this observer, but the task to erase
+    // the observer from the map hasn't been run.
+    if (observer->blimp_contents())
+      return observer->blimp_contents();
+  }
+  return nullptr;
+}
+
+int BlimpContentsManager::CreateBlimpContentsId() {
+  // TODO(mlliu): currently, Blimp only supports a single tab, so returning a
+  // dummy tab id. Need to return real case id when Blimp supports multiple
+  // tabs.
+  return kDummyTabId;
+}
+
+void BlimpContentsManager::EraseObserverFromMap(int id) {
+  observer_map_.erase(id);
+}
+
+}  // namespace client
+}  // namespace blimp