Add network throttling as an enterprise policy

chromeos/dbus/shill_manager_client_unittest.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/dbus/shill_manager_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 34 matching lines @@
     std::string arg_string;
     ASSERT_TRUE(reader->PopString(&arg_string));
     EXPECT_EQ(*iter, arg_string);
   }
   dbus::ObjectPath path;
   ASSERT_TRUE(reader->PopObjectPath(&path));
   EXPECT_EQ(object_path, path);
   EXPECT_FALSE(reader->HasMoreData());
 }
 
+void ExpectThrottlingArguments(bool throttling_enabled_expected,
+                               uint32_t upload_rate_kbits_expected,
+                               uint32_t download_rate_kbits_expected,
+                               dbus::MessageReader* reader) {
+  bool throttling_enabled_actual;
+  uint32_t upload_rate_kbits_actual;
+  uint32_t download_rate_kbits_actual;
+  ASSERT_TRUE(reader->PopBool(&throttling_enabled_actual));
+  EXPECT_EQ(throttling_enabled_actual, throttling_enabled_expected);

[Lei Zhang, 2016/10/29 16:04:05]

nit: EXPECT_EQ(expected, actual) - reverse the arguments.

+  ASSERT_TRUE(reader->PopUint32(&upload_rate_kbits_actual));
+  EXPECT_EQ(upload_rate_kbits_expected, upload_rate_kbits_actual);
+  ASSERT_TRUE(reader->PopUint32(&download_rate_kbits_actual));
+  EXPECT_EQ(download_rate_kbits_expected, download_rate_kbits_actual);
+  EXPECT_FALSE(reader->HasMoreData());
+}
 
 }  // namespace
 
 class ShillManagerClientTest : public ShillClientUnittestBase {
  public:
   ShillManagerClientTest()
       : ShillClientUnittestBase(shill::kFlimflamManagerInterface,
                                 dbus::ObjectPath(shill::kFlimflamServicePath)) {
   }
 
@@ skipping 177 matching lines @@
   client_->EnableTechnology(shill::kTypeWifi,
                             mock_closure.GetCallback(),
                             mock_error_callback.GetCallback());
   EXPECT_CALL(mock_closure, Run()).Times(1);
   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 
   // Run the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
+TEST_F(ShillManagerClientTest, NetworkThrottling) {
+  // Create response.
+  std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  // Set expectations.
+  const bool enabled = true;
+  const uint32_t upload_rate = 1200;
+  const uint32_t download_rate = 2000;
+  PrepareForMethodCall(shill::kSetNetworkThrottlingFunction,
+                       base::Bind(&ExpectThrottlingArguments, enabled,
+                                  upload_rate, download_rate),
+                       response.get());
+  // Call method.
+  MockClosure mock_closure;
+  MockErrorCallback mock_error_callback;
+  client_->SetNetworkThrottlingStatus(enabled, upload_rate, download_rate,
+                                      mock_closure.GetCallback(),
+                                      mock_error_callback.GetCallback());
+  EXPECT_CALL(mock_closure, Run()).Times(1);
+  EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
+
+  // Run the message loop.
+  base::RunLoop().RunUntilIdle();
+}
+
 TEST_F(ShillManagerClientTest, DisableTechnology) {
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   // Set expectations.
   PrepareForMethodCall(shill::kDisableTechnologyFunction,
                        base::Bind(&ExpectStringArgument, shill::kTypeWifi),
                        response.get());
   // Call method.
   MockClosure mock_closure;
   MockErrorCallback mock_error_callback;
@@ skipping 179 matching lines @@
       arguments[7],
       base::Bind(&ExpectStringResultWithoutStatus, expected),
       mock_error_callback.GetCallback());
   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 
   // Run the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace chromeos