Add network throttling as an enterprise policy

chrome/browser/chromeos/policy/device_policy_decoder_chromeos.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 "chrome/browser/chromeos/policy/device_policy_decoder_chromeos.h"
 
 #include <limits>
+#include <memory>
 #include <string>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
@@ skipping 306 matching lines @@
     const em::DataRoamingEnabledProto& container(policy.data_roaming_enabled());
     if (container.has_data_roaming_enabled()) {
       policies->Set(key::kDeviceDataRoamingEnabled, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     base::MakeUnique<base::FundamentalValue>(
                         container.data_roaming_enabled()),
                     nullptr);
     }
   }
 
+  if (policy.has_network_throttling()) {
+    const em::NetworkThrottlingEnabledProto& container(
+        policy.network_throttling());
+    std::unique_ptr<base::DictionaryValue> throttling_status(
+        new base::DictionaryValue());
+    bool enabled = (container.has_enabled()) ? container.enabled() : false;
+    uint32_t upload_rate_kbits =
+        (container.has_upload_rate_kbits()) ? container.upload_rate_kbits() : 0;
+    uint32_t download_rate_kbits = (container.has_download_rate_kbits())
+                                       ? container.download_rate_kbits()
+                                       : 0;
+
+    throttling_status->SetBoolean("enabled", enabled);
+    throttling_status->SetInteger("upload_rate_kbits", upload_rate_kbits);
+    throttling_status->SetInteger("download_rate_kbits", download_rate_kbits);
+    policies->Set(key::kNetworkThrottlingEnabled, POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                  std::move(throttling_status), nullptr);
+  }
+
   if (policy.has_open_network_configuration() &&
       policy.open_network_configuration().has_open_network_configuration()) {
     std::string config(
         policy.open_network_configuration().open_network_configuration());
     policies->Set(key::kDeviceOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                   base::MakeUnique<base::StringValue>(config), nullptr);
   }
 }
 
@@ skipping 469 matching lines @@
   // Decode the various groups of policies.
   DecodeLoginPolicies(policy, policies);
   DecodeNetworkPolicies(policy, policies);
   DecodeReportingPolicies(policy, policies);
   DecodeAutoUpdatePolicies(policy, policies);
   DecodeAccessibilityPolicies(policy, policies);
   DecodeGenericPolicies(policy, policies);
 }
 
 }  // namespace policy