Add ONC 'Source' configuration property

chromeos/network/onc/onc_translator_shill_to_onc.cc

 // Copyright (c) 2012 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 "chromeos/network/onc/onc_translator.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
+#include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translation_tables.h"
 #include "chromeos/network/shill_property_util.h"
 #include "components/onc/onc_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 namespace onc {
@@ skipping 18 matching lines @@
   return make_scoped_ptr(value);
 }
 
 // This class implements the translation of properties from the given
 // |shill_dictionary| to a new ONC object of signature |onc_signature|. Using
 // recursive calls to CreateTranslatedONCObject of new instances, nested objects
 // are translated.
 class ShillToONCTranslator {
  public:
   ShillToONCTranslator(const base::DictionaryValue& shill_dictionary,
+                       ::onc::ONCSource onc_source,
                        const OncValueSignature& onc_signature)
       : shill_dictionary_(&shill_dictionary),
+        onc_source_(onc_source),
         onc_signature_(&onc_signature) {
     field_translation_table_ = GetFieldTranslationTable(onc_signature);
   }
 
   ShillToONCTranslator(const base::DictionaryValue& shill_dictionary,
+                       ::onc::ONCSource onc_source,
                        const OncValueSignature& onc_signature,
                        const FieldTranslationEntry* field_translation_table)
       : shill_dictionary_(&shill_dictionary),
+        onc_source_(onc_source),
         onc_signature_(&onc_signature),
         field_translation_table_(field_translation_table) {
   }
 
   // Translates the associated Shill dictionary and creates an ONC object of the
   // given signature.
   scoped_ptr<base::DictionaryValue> CreateTranslatedONCObject();
 
  private:
   void TranslateEthernet();
@@ skipping 52 matching lines @@
   // |onc_object_|.
   void TranslateWithTableAndSet(const std::string& shill_property_name,
                                 const StringTranslationEntry table[],
                                 const std::string& onc_field_name);
 
   // Returns the name of the Shill service provided in |shill_dictionary_|
   // for debugging.
   std::string GetName();
 
   const base::DictionaryValue* shill_dictionary_;
+  ::onc::ONCSource onc_source_;
   const OncValueSignature* onc_signature_;
   const FieldTranslationEntry* field_translation_table_;
   scoped_ptr<base::DictionaryValue> onc_object_;
 
   DISALLOW_COPY_AND_ASSIGN(ShillToONCTranslator);
 };
 
 scoped_ptr<base::DictionaryValue>
 ShillToONCTranslator::CreateTranslatedONCObject() {
   onc_object_.reset(new base::DictionaryValue);
@@ skipping 190 matching lines @@
     TranslateAndAddNestedObject(::onc::cellular::kLastGoodAPN, *dictionary);
   }
   // Merge the Device dictionary with this one (Cellular) using the
   // CellularDevice signature.
   const base::DictionaryValue* device_dictionary = NULL;
   if (!shill_dictionary_->GetDictionaryWithoutPathExpansion(
           shill::kDeviceProperty, &device_dictionary)) {
     return;
   }
   ShillToONCTranslator nested_translator(*device_dictionary,
+                                         onc_source_,
                                          kCellularWithStateSignature,
                                          kCellularDeviceTable);
   scoped_ptr<base::DictionaryValue> nested_object =
       nested_translator.CreateTranslatedONCObject();
   onc_object_->MergeDictionary(nested_object.get());
 }
 
 void ShillToONCTranslator::TranslateCellularDevice() {
   CopyPropertiesAccordingToSignature();
   const base::DictionaryValue* shill_sim_lock_status = NULL;
@@ skipping 53 matching lines @@
     }
     onc_object_->SetStringWithoutPathExpansion(
         ::onc::network_config::kConnectionState, onc_state);
     // Only set 'RestrictedConnectivity' if true.
     if (state == shill::kStatePortal) {
       onc_object_->SetBooleanWithoutPathExpansion(
           ::onc::network_config::kRestrictedConnectivity, true);
     }
   }
 
+  std::string profile_path;
+  if (shill_dictionary_->GetStringWithoutPathExpansion(shill::kProfileProperty,
+                                                       &profile_path)) {
+    std::string source;
+    if (onc_source_ == ::onc::ONC_SOURCE_DEVICE_POLICY)
+      source = ::onc::network_config::kSourceDevicePolicy;
+    else if (onc_source_ == ::onc::ONC_SOURCE_USER_POLICY)
+      source = ::onc::network_config::kSourceUserPolicy;
+    else if (profile_path == NetworkProfileHandler::GetSharedProfilePath())
+      source = ::onc::network_config::kSourceDevice;
+    else if (!profile_path.empty())
+      source = ::onc::network_config::kSourceUser;
+    else

[pneubeck (no reviews), 2014/09/10 10:49:38]

please add a comment that ONC_SOURCE_USER_IMPORT (which should actually be
removed, IMO), is handled the same as ONC_SOURCE_NONE.
Which I agree that it should.

[stevenjb, 2014/09/10 17:32:15]

Yeah, I have no clue what USER_IMPORT is even for. I will add a comment in the
header.

[pneubeck (no reviews), 2014/09/10 20:22:38]

USER_IMPORT is set if a user imports an ONC file from net-internals/#chromeos .
Many releases ago (at the ages of NetworkLibrary) that had a similar effect as
policy.
But it should really be _exactly_ the same as if the user had used the UI. Thus
this source is just not be used...

+      source = ::onc::network_config::kSourceNone;
+    onc_object_->SetStringWithoutPathExpansion(
+        ::onc::network_config::kSource, source);
+  }
+
   // Use a human-readable aa:bb format for any hardware MAC address. Note:
   // this property is provided by the caller but is not part of the Shill
   // Service properties (it is copied from the Device properties).
   std::string address;
   if (shill_dictionary_->GetStringWithoutPathExpansion(shill::kAddressProperty,
                                                        &address)) {
     onc_object_->SetStringWithoutPathExpansion(
         ::onc::network_config::kMacAddress,
         network_util::FormattedMacAddress(address));
   }
@@ skipping 72 matching lines @@
 
 void ShillToONCTranslator::TranslateAndAddNestedObject(
     const std::string& onc_field_name,
     const base::DictionaryValue& dictionary) {
   const OncFieldSignature* field_signature =
       GetFieldSignature(*onc_signature_, onc_field_name);
   if (!field_signature) {
     NOTREACHED() << "Unable to find signature for field: " << onc_field_name;
     return;
   }
-  ShillToONCTranslator nested_translator(dictionary,
-                                         *field_signature->value_signature);
+  ShillToONCTranslator nested_translator(
+      dictionary, onc_source_, *field_signature->value_signature);
   scoped_ptr<base::DictionaryValue> nested_object =
       nested_translator.CreateTranslatedONCObject();
   if (nested_object->empty())
     return;
   onc_object_->SetWithoutPathExpansion(onc_field_name, nested_object.release());
 }
 
 void ShillToONCTranslator::SetNestedOncValue(
     const std::string& onc_dictionary_name,
     const std::string& onc_field_name,
@@ skipping 20 matching lines @@
   }
   DCHECK(field_signature->value_signature->onc_array_entry_signature);
   scoped_ptr<base::ListValue> result(new base::ListValue());
   for (base::ListValue::const_iterator it = list.begin();
        it != list.end(); ++it) {
     const base::DictionaryValue* shill_value = NULL;
     if (!(*it)->GetAsDictionary(&shill_value))
       continue;
     ShillToONCTranslator nested_translator(
         *shill_value,
+        onc_source_,
         *field_signature->value_signature->onc_array_entry_signature);
     scoped_ptr<base::DictionaryValue> nested_object =
         nested_translator.CreateTranslatedONCObject();
     // If the nested object couldn't be parsed, simply omit it.
     if (nested_object->empty())
       continue;
     result->Append(nested_object.release());
   }
   // If there are no entries in the list, there is no need to expose this field.
   if (result->empty())
@@ skipping 67 matching lines @@
   DCHECK(shill_dictionary_);
   std::string name;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kNameProperty, &name);
   return name;
 }
 
 }  // namespace
 
 scoped_ptr<base::DictionaryValue> TranslateShillServiceToONCPart(
     const base::DictionaryValue& shill_dictionary,
+    ::onc::ONCSource onc_source,
     const OncValueSignature* onc_signature) {
   CHECK(onc_signature != NULL);
 
-  ShillToONCTranslator translator(shill_dictionary, *onc_signature);
+  ShillToONCTranslator translator(shill_dictionary, onc_source, *onc_signature);
   return translator.CreateTranslatedONCObject();
 }
 
 }  // namespace onc
 }  // namespace chromeos