Mojo: removing support for process-group.

services/catalog/entry.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 "services/catalog/entry.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "services/catalog/store.h"
 #include "services/service_manager/public/cpp/names.h"
@@ skipping 81 matching lines @@
     }
   }
   return true;
 }
 
 }  // namespace
 
 Entry::Entry() {}
 Entry::Entry(const std::string& name)
     : name_(name),
-      qualifier_(service_manager::GetNamePath(name)),
       display_name_(name) {}
 Entry::~Entry() {}
 
 std::unique_ptr<base::DictionaryValue> Entry::Serialize() const {
   auto value = base::MakeUnique<base::DictionaryValue>();
   value->SetString(Store::kNameKey, name_);
   value->SetString(Store::kDisplayNameKey, display_name_);
-  value->SetString(Store::kQualifierKey, qualifier_);
 
   auto specs = base::MakeUnique<base::DictionaryValue>();
   for (const auto& it : interface_provider_specs_) {
     auto spec = base::MakeUnique<base::DictionaryValue>();
 
     auto provides = base::MakeUnique<base::DictionaryValue>();
     for (const auto& i : it.second.provides) {
       auto interfaces = base::MakeUnique<base::ListValue>();
       for (const auto& interface_name : i.second)
         interfaces->AppendString(interface_name);
@@ skipping 26 matching lines @@
                << Store::kNameKey << " key";
     return nullptr;
   }
   if (!service_manager::IsValidName(name_string)) {
     LOG(ERROR) << "Entry::Deserialize: " << name_string << " is not a valid "
                << "Mojo name";
     return nullptr;
   }
   entry->set_name(name_string);
 
-  // Process group.
-  if (value.HasKey(Store::kQualifierKey)) {
-    std::string qualifier;
-    if (!value.GetString(Store::kQualifierKey, &qualifier)) {
-      LOG(ERROR) << "Entry::Deserialize: " << Store::kQualifierKey << " must "
-                 << "be a string.";
-      return nullptr;
-    }
-    entry->set_qualifier(qualifier);
-  } else {
-    entry->set_qualifier(service_manager::GetNamePath(name_string));
-  }
-
   // Human-readable name.
   std::string display_name;
   if (!value.GetString(Store::kDisplayNameKey, &display_name)) {
     LOG(ERROR) << "Entry::Deserialize: dictionary has no "
                << Store::kDisplayNameKey << " key";
     return nullptr;
   }
   entry->set_display_name(display_name);
 
   // InterfaceProvider specs.
@@ skipping 46 matching lines @@
       service_manager::mojom::kServiceManager_ConnectorSpec);
   if (it == interface_provider_specs_.end())
     return false;
 
   auto connection_spec = it->second;
   return connection_spec.provides.find(capability) !=
       connection_spec.provides.end();
 }
 
 bool Entry::operator==(const Entry& other) const {
-  return other.name_ == name_ && other.qualifier_ == qualifier_ &&
+  return other.name_ == name_ &&
          other.display_name_ == display_name_ &&
          other.interface_provider_specs_ == interface_provider_specs_;
 }
 
 void Entry::AddInterfaceProviderSpec(
     const std::string& name,
     const service_manager::InterfaceProviderSpec& spec) {
   interface_provider_specs_[name] = spec;
 }
 
 }  // catalog
 
 namespace mojo {
 
 // static
 service_manager::mojom::ResolveResultPtr
 TypeConverter<service_manager::mojom::ResolveResultPtr,
               catalog::Entry>::Convert(const catalog::Entry& input) {
   service_manager::mojom::ResolveResultPtr result(
       service_manager::mojom::ResolveResult::New());
   result->name = input.name();
   const catalog::Entry& package = input.package() ? *input.package() : input;
   result->resolved_name = package.name();
-  result->qualifier = input.qualifier();
   result->interface_provider_specs = input.interface_provider_specs();
   if (input.package()) {
     auto it = package.interface_provider_specs().find(
         service_manager::mojom::kServiceManager_ConnectorSpec);
     if (it != package.interface_provider_specs().end())
       result->package_spec = it->second;
   }
   result->package_path = package.path();
   return result;
 }
 
 // static
 catalog::mojom::EntryPtr
     TypeConverter<catalog::mojom::EntryPtr, catalog::Entry>::Convert(
         const catalog::Entry& input) {
   catalog::mojom::EntryPtr result(catalog::mojom::Entry::New());
   result->name = input.name();
   result->display_name = input.display_name();
   return result;
 }
 
 }  // namespace mojo