Make Service own ServiceContext.

mash/task_viewer/task_viewer.cc

 // Copyright 2015 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 "mash/task_viewer/task_viewer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 56 matching lines @@
     kill_button_->SetStyle(views::Button::STYLE_BUTTON);
     AddChildView(kill_button_);
   }
   ~TaskViewerContents() override {
     table_view_->SetModel(nullptr);
     task_viewer_->RemoveWindow(GetWidget());
   }
 
  private:
   struct InstanceInfo {
-    InstanceInfo(uint32_t id,
-                 const std::string& url,
-                 base::ProcessId pid)
-        : id(id), url(url), pid(pid) {}
-    uint32_t id;
-    std::string url;
+    InstanceInfo(const shell::Identity& identity, base::ProcessId pid)
+        : identity(identity), pid(pid) {}
+    shell::Identity identity;
     uint32_t pid;
-    std::string name;
+    std::string display_name;
   };
 
 
   // Overridden from views::WidgetDelegate:
   views::View* GetContentsView() override { return this; }
   base::string16 GetWindowTitle() const override {
     // TODO(beng): use resources.
     return base::ASCIIToUTF16("Tasks");
   }
   bool CanResize() const override { return true; }
@@ skipping 22 matching lines @@
   }
 
   // Overridden from ui::TableModel:
   int RowCount() override {
     return static_cast<int>(instances_.size());
   }
   base::string16 GetText(int row, int column_id) override {
     switch(column_id) {
     case 0:
       DCHECK(row < static_cast<int>(instances_.size()));
-      return base::UTF8ToUTF16(instances_[row]->name);
+      return base::UTF8ToUTF16(instances_[row]->display_name);
     case 1:
       DCHECK(row < static_cast<int>(instances_.size()));
-      return base::UTF8ToUTF16(instances_[row]->url);
+      return base::UTF8ToUTF16(instances_[row]->identity.name());
     case 2:
       DCHECK(row < static_cast<int>(instances_.size()));
       return base::IntToString16(instances_[row]->pid);
     default:
       NOTREACHED();
       break;
     }
     return base::string16();
   }
   void SetObserver(ui::TableModelObserver* observer) override {
     observer_ = observer;
   }
 
   // Overridden from views::ButtonListener:
   void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     DCHECK_EQ(sender, kill_button_);
     DCHECK_EQ(table_view_->SelectedRowCount(), 1);
     int row = table_view_->FirstSelectedRow();
     DCHECK(row < static_cast<int>(instances_.size()));
     base::Process process = base::Process::Open(instances_[row]->pid);
     process.Terminate(9, true);
   }
 
   // Overridden from shell::mojom::ServiceManagerListener:
   void OnInit(mojo::Array<ServiceInfoPtr> instances) override {
     // This callback should only be called with an empty model.
     DCHECK(instances_.empty());
     mojo::Array<mojo::String> names;
     for (size_t i = 0; i < instances.size(); ++i) {
-      InsertInstance(instances[i]->id, instances[i]->identity->name,
-                     instances[i]->pid);
-      names.push_back(instances[i]->identity->name);
+      shell::Identity identity = instances[i]->identity.To<shell::Identity>();
+      InsertInstance(identity, instances[i]->pid);
+      names.push_back(identity.name());
     }
     catalog_->GetEntries(std::move(names),
                          base::Bind(&TaskViewerContents::OnGotCatalogEntries,
                                     weak_ptr_factory_.GetWeakPtr()));
   }
   void OnServiceCreated(ServiceInfoPtr instance) override {
-    DCHECK(!ContainsId(instance->id));
-    InsertInstance(instance->id, instance->identity->name, instance->pid);
+    shell::Identity identity = instance->identity.To<shell::Identity>();
+    DCHECK(!ContainsIdentity(identity));
+    InsertInstance(identity, instance->pid);
     observer_->OnItemsAdded(static_cast<int>(instances_.size()), 1);
     mojo::Array<mojo::String> names;
-    names.push_back(instance->identity->name);
+    names.push_back(identity.name());
     catalog_->GetEntries(std::move(names),
                          base::Bind(&TaskViewerContents::OnGotCatalogEntries,
                                     weak_ptr_factory_.GetWeakPtr()));
   }
-  void OnServiceStarted(uint32_t id, uint32_t pid) override {
+  void OnServiceStarted(shell::mojom::IdentityPtr identity_ptr,
+                        uint32_t pid) override {
+    shell::Identity identity = identity_ptr.To<shell::Identity>();
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
-      if ((*it)->id == id) {
+      if ((*it)->identity == identity) {
         (*it)->pid = pid;
         observer_->OnItemsChanged(
           static_cast<int>(it - instances_.begin()), 1);
         return;
       }
     }
   }
-  void OnServiceStopped(uint32_t id) override {
+  void OnServiceStopped(shell::mojom::IdentityPtr identity_ptr) override {
+    shell::Identity identity = identity_ptr.To<shell::Identity>();
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
-      if ((*it)->id == id) {
+      if ((*it)->identity == identity) {
         observer_->OnItemsRemoved(
             static_cast<int>(it - instances_.begin()), 1);
         instances_.erase(it);
         return;
       }
     }
     NOTREACHED();
   }
 
-  bool ContainsId(uint32_t id) const {
+  bool ContainsIdentity(const shell::Identity& identity) const {
     for (auto& it : instances_) {
-      if (it->id == id)
+      if (it->identity == identity)
         return true;
     }
     return false;
   }
 
-  void InsertInstance(uint32_t id, const std::string& url, uint32_t pid) {
-    instances_.push_back(base::WrapUnique(new InstanceInfo(id, url, pid)));
+  void InsertInstance(const shell::Identity& identity, uint32_t pid) {
+    instances_.push_back(
+        base::WrapUnique(new InstanceInfo(identity, pid)));
   }
 
   void OnGotCatalogEntries(mojo::Array<catalog::mojom::EntryPtr> entries) {
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
       for (auto& entry : entries) {
-        if (entry->name == (*it)->url) {
-          (*it)->name = entry->display_name;
+        if (entry->name == (*it)->identity.name()) {
+          (*it)->display_name = entry->display_name;
           observer_->OnItemsChanged(
               static_cast<int>(it - instances_.begin()), 1);
           break;
         }
       }
     }
   }
 
   static std::vector<ui::TableColumn> GetColumns() {
     std::vector<ui::TableColumn> columns;
@@ skipping 49 matching lines @@
 TaskViewer::~TaskViewer() {}
 
 void TaskViewer::RemoveWindow(views::Widget* widget) {
   auto it = std::find(windows_.begin(), windows_.end(), widget);
   DCHECK(it != windows_.end());
   windows_.erase(it);
   if (windows_.empty())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
-void TaskViewer::OnStart(shell::Connector* connector,
-                         const shell::Identity& identity,
-                         uint32_t id) {
-  connector_ = connector;
-  tracing_.Initialize(connector, identity.name());
+void TaskViewer::OnStart(const shell::Identity& identity) {
+  tracing_.Initialize(connector(), identity.name());
 
-  aura_init_.reset(new views::AuraInit(connector, "views_mus_resources.pak"));
+  aura_init_.reset(
+      new views::AuraInit(connector(), "views_mus_resources.pak"));
   window_manager_connection_ =
-      views::WindowManagerConnection::Create(connector, identity);
+      views::WindowManagerConnection::Create(connector(), identity);
 }
 
 bool TaskViewer::OnConnect(shell::Connection* connection) {
   connection->AddInterface<mojom::Launchable>(this);
   return true;
 }
 
 void TaskViewer::Launch(uint32_t what, mojom::LaunchMode how) {
   bool reuse = how == mojom::LaunchMode::REUSE ||
                how == mojom::LaunchMode::DEFAULT;
   if (reuse && !windows_.empty()) {
     windows_.back()->Activate();
     return;
   }
 
   shell::mojom::ServiceManagerPtr service_manager;
-  connector_->ConnectToInterface("mojo:shell", &service_manager);
+  connector()->ConnectToInterface("mojo:shell", &service_manager);
 
   shell::mojom::ServiceManagerListenerPtr listener;
   shell::mojom::ServiceManagerListenerRequest request = GetProxy(&listener);
   service_manager->AddListener(std::move(listener));
 
   catalog::mojom::CatalogPtr catalog;
-  connector_->ConnectToInterface("mojo:catalog", &catalog);
+  connector()->ConnectToInterface("mojo:catalog", &catalog);
 
   TaskViewerContents* task_viewer = new TaskViewerContents(
       this, std::move(request), std::move(catalog));
   views::Widget* window = views::Widget::CreateWindowWithContextAndBounds(
       task_viewer, nullptr, gfx::Rect(10, 10, 500, 500));
   window->Show();
   windows_.push_back(window);
 }
 
 void TaskViewer::Create(const shell::Identity& remote_identity,
                         mojom::LaunchableRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace task_viewer
 }  // namespace main