Updated the formatting for the app remoting test driver files using clag-format for consistency. N…

remoting/test/remote_host_info_fetcher_unittest.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 "remoting/test/remote_host_info_fetcher.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
@@ skipping 25 matching lines @@
 namespace remoting {
 namespace test {
 
 // Provides base functionality for the RemoteHostInfoFetcher Tests below.  The
 // FakeURLFetcherFactory allows us to override the response data and payload for
 // specified URLs.  We use this to stub out network calls made by the
 // RemoteHostInfoFetcher.  This fixture also creates an IO MessageLoop, if
 // necessary, for use by the RemoteHostInfoFetcher.
 class RemoteHostInfoFetcherTest : public ::testing::Test {
  public:
-  RemoteHostInfoFetcherTest() :
-    url_fetcher_factory_(nullptr) {}
+  RemoteHostInfoFetcherTest() : url_fetcher_factory_(nullptr) {}
   ~RemoteHostInfoFetcherTest() override {}
 
   // Used as a RemoteHostInfoCallback for testing.
   void OnRemoteHostInfoRetrieved(
-    base::Closure done_closure,
-    const RemoteHostInfo& retrieved_remote_host_info);
+      base::Closure done_closure,
+      const RemoteHostInfo& retrieved_remote_host_info);
 
  protected:
   // testing::Test interface.
   void SetUp() override;
 
   // Sets the HTTP status and data returned for a specified URL.
-  void SetFakeResponse(
-      const GURL& url,
-      const std::string& data,
-      net::HttpStatusCode code,
-      net::URLRequestStatus::Status status);
+  void SetFakeResponse(const GURL& url,
+                       const std::string& data,
+                       net::HttpStatusCode code,
+                       net::URLRequestStatus::Status status);
 
   // Used for result verification.
   RemoteHostInfo remote_host_info_;
 
  protected:
   std::string dev_service_environment_url_;
   std::string test_service_environment_url_;
 
  private:
   net::FakeURLFetcherFactory url_fetcher_factory_;
@@ skipping 10 matching lines @@
   done_closure.Run();
 }
 
 void RemoteHostInfoFetcherTest::SetUp() {
   if (!base::MessageLoop::current()) {
     // Create a temporary message loop if the current thread does not already
     // have one so we can use its task runner to create a request object.
     message_loop_.reset(new base::MessageLoopForIO);
   }
 
-  dev_service_environment_url_ = base::StringPrintf(
-      kDevServiceEnvironmentUrlFormat,
-      kTestApplicationId);
+  dev_service_environment_url_ =
+      base::StringPrintf(kDevServiceEnvironmentUrlFormat, kTestApplicationId);
 
-  test_service_environment_url_ = base::StringPrintf(
-      kTestServiceEnvironmentUrlFormat,
-      kTestApplicationId);
+  test_service_environment_url_ =
+      base::StringPrintf(kTestServiceEnvironmentUrlFormat, kTestApplicationId);
 }
 
 void RemoteHostInfoFetcherTest::SetFakeResponse(
     const GURL& url,
     const std::string& data,
     net::HttpStatusCode code,
     net::URLRequestStatus::Status status) {
   url_fetcher_factory_.SetFakeResponse(url, data, code, status);
 }
 
 TEST_F(RemoteHostInfoFetcherTest, RetrieveRemoteHostInfoFromDev) {
-  SetFakeResponse(
-      GURL(dev_service_environment_url_),
-      kRemoteHostInfoReadyResponse,
-      net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  SetFakeResponse(GURL(dev_service_environment_url_),
+                  kRemoteHostInfoReadyResponse, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
-  SetFakeResponse(
-      GURL(test_service_environment_url_),
-      kRemoteHostInfoEmptyResponse,
-      net::HTTP_NOT_FOUND,
-      net::URLRequestStatus::FAILED);
+  SetFakeResponse(GURL(test_service_environment_url_),
+                  kRemoteHostInfoEmptyResponse, net::HTTP_NOT_FOUND,
+                  net::URLRequestStatus::FAILED);
 
   base::RunLoop run_loop;
   RemoteHostInfoCallback remote_host_info_callback =
       base::Bind(&RemoteHostInfoFetcherTest::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 run_loop.QuitClosure());
+                 base::Unretained(this), run_loop.QuitClosure());
 
   RemoteHostInfoFetcher remote_host_info_fetcher;
   bool request_started = remote_host_info_fetcher.RetrieveRemoteHostInfo(
-      kTestApplicationId,
-      kAccessTokenValue,
-      kDeveloperEnvironment,
+      kTestApplicationId, kAccessTokenValue, kDeveloperEnvironment,
       remote_host_info_callback);
 
   run_loop.Run();
 
   EXPECT_TRUE(request_started);
   EXPECT_TRUE(remote_host_info_.IsReadyForConnection());
   EXPECT_EQ(remote_host_info_.application_id.compare(kTestApplicationId), 0);
   EXPECT_TRUE(!remote_host_info_.host_id.empty());
   EXPECT_TRUE(!remote_host_info_.host_jid.empty());
   EXPECT_TRUE(!remote_host_info_.authorization_code.empty());
   EXPECT_TRUE(!remote_host_info_.shared_secret.empty());
 }
 
 TEST_F(RemoteHostInfoFetcherTest, RetrieveRemoteHostInfoFromTest) {
-  SetFakeResponse(
-      GURL(test_service_environment_url_),
-      kRemoteHostInfoReadyResponse,
-      net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  SetFakeResponse(GURL(test_service_environment_url_),
+                  kRemoteHostInfoReadyResponse, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
-  SetFakeResponse(
-      GURL(dev_service_environment_url_),
-      kRemoteHostInfoEmptyResponse,
-      net::HTTP_NOT_FOUND,
-      net::URLRequestStatus::FAILED);
+  SetFakeResponse(GURL(dev_service_environment_url_),
+                  kRemoteHostInfoEmptyResponse, net::HTTP_NOT_FOUND,
+                  net::URLRequestStatus::FAILED);
 
   base::RunLoop run_loop;
   RemoteHostInfoCallback remote_host_info_callback =
       base::Bind(&RemoteHostInfoFetcherTest::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 run_loop.QuitClosure());
+                 base::Unretained(this), run_loop.QuitClosure());
 
   RemoteHostInfoFetcher remote_host_info_fetcher;
   bool request_started = remote_host_info_fetcher.RetrieveRemoteHostInfo(
-      kTestApplicationId,
-      kAccessTokenValue,
-      kTestingEnvironment,
+      kTestApplicationId, kAccessTokenValue, kTestingEnvironment,
       remote_host_info_callback);
 
   run_loop.Run();
 
   EXPECT_TRUE(request_started);
   EXPECT_TRUE(remote_host_info_.IsReadyForConnection());
   EXPECT_EQ(remote_host_info_.application_id.compare(kTestApplicationId), 0);
   EXPECT_TRUE(!remote_host_info_.host_id.empty());
   EXPECT_TRUE(!remote_host_info_.host_jid.empty());
   EXPECT_TRUE(!remote_host_info_.authorization_code.empty());
   EXPECT_TRUE(!remote_host_info_.shared_secret.empty());
 }
 
 TEST_F(RemoteHostInfoFetcherTest, RetrieveRemoteHostInfoInvalidEnvironment) {
   base::RunLoop run_loop;
   RemoteHostInfoCallback remote_host_info_callback =
       base::Bind(&RemoteHostInfoFetcherTest::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 run_loop.QuitClosure());
+                 base::Unretained(this), run_loop.QuitClosure());
 
   RemoteHostInfoFetcher remote_host_info_fetcher;
   bool request_started = remote_host_info_fetcher.RetrieveRemoteHostInfo(
-      kTestApplicationId,
-      kAccessTokenValue,
-      kUnknownEnvironment,
+      kTestApplicationId, kAccessTokenValue, kUnknownEnvironment,
       remote_host_info_callback);
 
   EXPECT_FALSE(request_started);
 }
 
 TEST_F(RemoteHostInfoFetcherTest, RetrieveRemoteHostInfoNetworkError) {
-  SetFakeResponse(
-      GURL(dev_service_environment_url_),
-      kRemoteHostInfoReadyResponse,
-      net::HTTP_NOT_FOUND,
-      net::URLRequestStatus::FAILED);
+  SetFakeResponse(GURL(dev_service_environment_url_),
+                  kRemoteHostInfoReadyResponse, net::HTTP_NOT_FOUND,
+                  net::URLRequestStatus::FAILED);
 
   base::RunLoop run_loop;
   RemoteHostInfoCallback remote_host_info_callback =
       base::Bind(&RemoteHostInfoFetcherTest::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 run_loop.QuitClosure());
+                 base::Unretained(this), run_loop.QuitClosure());
 
   RemoteHostInfoFetcher remote_host_info_fetcher;
   bool request_started = remote_host_info_fetcher.RetrieveRemoteHostInfo(
-      kTestApplicationId,
-      kAccessTokenValue,
-      kDeveloperEnvironment,
+      kTestApplicationId, kAccessTokenValue, kDeveloperEnvironment,
       remote_host_info_callback);
 
   run_loop.Run();
 
   EXPECT_TRUE(request_started);
   EXPECT_FALSE(remote_host_info_.IsReadyForConnection());
 
   // If there was a network error retrieving the remote host info, then none of
   // the connection details should be populated.
   EXPECT_TRUE(remote_host_info_.application_id.empty());
   EXPECT_TRUE(remote_host_info_.host_id.empty());
   EXPECT_TRUE(remote_host_info_.host_jid.empty());
   EXPECT_TRUE(remote_host_info_.authorization_code.empty());
   EXPECT_TRUE(remote_host_info_.shared_secret.empty());
 }
 
 TEST_F(RemoteHostInfoFetcherTest, RetrieveRemoteHostInfoPendingResponse) {
-  SetFakeResponse(
-      GURL(dev_service_environment_url_),
-      kRemoteHostInfoPendingResponse,
-      net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  SetFakeResponse(GURL(dev_service_environment_url_),
+                  kRemoteHostInfoPendingResponse, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
   base::RunLoop run_loop;
   RemoteHostInfoCallback remote_host_info_callback =
       base::Bind(&RemoteHostInfoFetcherTest::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 run_loop.QuitClosure());
+                 base::Unretained(this), run_loop.QuitClosure());
 
   RemoteHostInfoFetcher remote_host_info_fetcher;
   bool request_started = remote_host_info_fetcher.RetrieveRemoteHostInfo(
-      kTestApplicationId,
-      kAccessTokenValue,
-      kDeveloperEnvironment,
+      kTestApplicationId, kAccessTokenValue, kDeveloperEnvironment,
       remote_host_info_callback);
 
   run_loop.Run();
 
   EXPECT_TRUE(request_started);
   EXPECT_FALSE(remote_host_info_.IsReadyForConnection());
 
   // If the remote host request is pending, then none of the connection details
   // should be populated.
   EXPECT_TRUE(remote_host_info_.application_id.empty());
   EXPECT_TRUE(remote_host_info_.host_id.empty());
   EXPECT_TRUE(remote_host_info_.host_jid.empty());
   EXPECT_TRUE(remote_host_info_.authorization_code.empty());
   EXPECT_TRUE(remote_host_info_.shared_secret.empty());
 }
 
 TEST_F(RemoteHostInfoFetcherTest, RetrieveRemoteHostInfoEmptyResponse) {
-  SetFakeResponse(
-      GURL(dev_service_environment_url_),
-      kRemoteHostInfoEmptyResponse,
-      net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  SetFakeResponse(GURL(dev_service_environment_url_),
+                  kRemoteHostInfoEmptyResponse, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
   base::RunLoop run_loop;
   RemoteHostInfoCallback remote_host_info_callback =
       base::Bind(&RemoteHostInfoFetcherTest::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 run_loop.QuitClosure());
+                 base::Unretained(this), run_loop.QuitClosure());
 
   RemoteHostInfoFetcher remote_host_info_fetcher;
   bool request_started = remote_host_info_fetcher.RetrieveRemoteHostInfo(
-      kTestApplicationId,
-      kAccessTokenValue,
-      kDeveloperEnvironment,
+      kTestApplicationId, kAccessTokenValue, kDeveloperEnvironment,
       remote_host_info_callback);
 
   run_loop.Run();
 
   EXPECT_TRUE(request_started);
   EXPECT_FALSE(remote_host_info_.IsReadyForConnection());
 
   // If we received an empty response, then none of the connection details
   // should be populated.
   EXPECT_TRUE(remote_host_info_.application_id.empty());
   EXPECT_TRUE(remote_host_info_.host_id.empty());
   EXPECT_TRUE(remote_host_info_.host_jid.empty());
   EXPECT_TRUE(remote_host_info_.authorization_code.empty());
   EXPECT_TRUE(remote_host_info_.shared_secret.empty());
 }
 
 TEST_F(RemoteHostInfoFetcherTest, MultipleRetrieveRemoteHostInfoRequests) {
   // First, we will fetch info from the development service environment.
-  SetFakeResponse(
-      GURL(dev_service_environment_url_),
-      kRemoteHostInfoReadyResponse,
-      net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  SetFakeResponse(GURL(dev_service_environment_url_),
+                  kRemoteHostInfoReadyResponse, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
-  SetFakeResponse(
-      GURL(test_service_environment_url_),
-      kRemoteHostInfoEmptyResponse,
-      net::HTTP_NOT_FOUND,
-      net::URLRequestStatus::FAILED);
+  SetFakeResponse(GURL(test_service_environment_url_),
+                  kRemoteHostInfoEmptyResponse, net::HTTP_NOT_FOUND,
+                  net::URLRequestStatus::FAILED);
 
   base::RunLoop dev_run_loop;
   RemoteHostInfoCallback dev_remote_host_info_callback =
       base::Bind(&RemoteHostInfoFetcherTest::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 dev_run_loop.QuitClosure());
+                 base::Unretained(this), dev_run_loop.QuitClosure());
 
   RemoteHostInfoFetcher remote_host_info_fetcher;
   bool dev_request_started = remote_host_info_fetcher.RetrieveRemoteHostInfo(
-      kTestApplicationId,
-      kAccessTokenValue,
-      kDeveloperEnvironment,
+      kTestApplicationId, kAccessTokenValue, kDeveloperEnvironment,
       dev_remote_host_info_callback);
 
   dev_run_loop.Run();
 
   EXPECT_TRUE(dev_request_started);
   EXPECT_TRUE(remote_host_info_.IsReadyForConnection());
   EXPECT_EQ(remote_host_info_.application_id.compare(kTestApplicationId), 0);
   EXPECT_TRUE(!remote_host_info_.host_id.empty());
   EXPECT_TRUE(!remote_host_info_.host_jid.empty());
   EXPECT_TRUE(!remote_host_info_.authorization_code.empty());
   EXPECT_TRUE(!remote_host_info_.shared_secret.empty());
 
   // Next, we will fetch info from the test service environment.
-  SetFakeResponse(
-      GURL(test_service_environment_url_),
-      kRemoteHostInfoReadyResponse,
-      net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  SetFakeResponse(GURL(test_service_environment_url_),
+                  kRemoteHostInfoReadyResponse, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
-  SetFakeResponse(
-      GURL(dev_service_environment_url_),
-      kRemoteHostInfoEmptyResponse,
-      net::HTTP_NOT_FOUND,
-      net::URLRequestStatus::FAILED);
+  SetFakeResponse(GURL(dev_service_environment_url_),
+                  kRemoteHostInfoEmptyResponse, net::HTTP_NOT_FOUND,
+                  net::URLRequestStatus::FAILED);
 
   base::RunLoop test_run_loop;
   RemoteHostInfoCallback test_remote_host_info_callback =
       base::Bind(&RemoteHostInfoFetcherTest::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 test_run_loop.QuitClosure());
+                 base::Unretained(this), test_run_loop.QuitClosure());
 
   // Reset the state of our internal |remote_host_info_| object.
   remote_host_info_ = RemoteHostInfo();
   EXPECT_FALSE(remote_host_info_.IsReadyForConnection());
 
   bool test_request_started = remote_host_info_fetcher.RetrieveRemoteHostInfo(
-      kTestApplicationId,
-      kAccessTokenValue,
-      kTestingEnvironment,
+      kTestApplicationId, kAccessTokenValue, kTestingEnvironment,
       test_remote_host_info_callback);
 
   test_run_loop.Run();
 
   EXPECT_TRUE(test_request_started);
   EXPECT_TRUE(remote_host_info_.IsReadyForConnection());
   EXPECT_EQ(remote_host_info_.application_id.compare(kTestApplicationId), 0);
   EXPECT_TRUE(!remote_host_info_.host_id.empty());
   EXPECT_TRUE(!remote_host_info_.host_jid.empty());
   EXPECT_TRUE(!remote_host_info_.authorization_code.empty());
   EXPECT_TRUE(!remote_host_info_.shared_secret.empty());
 }
 
 }  // namespace test
 }  // namespace remoting