Google Git
Sign in
weave/weave/libweave/815b603b59bebac4407322af61a822413ad421f6^!/.
commit
815b603b59bebac4407322af61a822413ad421f6
[log]
author
Vitaly Buka <vitalybuka@chromium.org>
Thu Aug 06 11:06:25 2015 -0700
committer
Alex Vakulenko <avakulenko@google.com>
Thu Aug 06 14:23:21 2015 -0700
tree
edc6938c6ba58b1e78d95d72fc5dd0ac9a293c16
parent
1da659947e800069a6352dbe7f829dfdf1697fed [diff]
libweave: Remove mime_type from HttpClient interface

This simplifies platform side implementation. The implementation will
just submit all headers as is.

BUG=brillo:1250
TEST=`FEATURES=test emerge-gizmo libweave buffet`

Change-Id: Id7f968fab5c18ca30223e456c04d36c2a0becb7e

diff --git a/libweave/include/weave/http_client.h b/libweave/include/weave/http_client.h
index 8263d21..401f1c5 100644
--- a/libweave/include/weave/http_client.h
+++ b/libweave/include/weave/http_client.h

@@ -34,16 +34,14 @@
   virtual std::unique_ptr<Response> SendRequestAndBlock(
       const std::string& method,
       const std::string& url,
-      const std::string& data,
-      const std::string& mime_type,
       const Headers& headers,
+      const std::string& data,
       chromeos::ErrorPtr* error) = 0;
 
   virtual int SendRequest(const std::string& method,
                           const std::string& url,
-                          const std::string& data,
-                          const std::string& mime_type,
                           const Headers& headers,
+                          const std::string& data,
                           const SuccessCallback& success_callback,
                           const ErrorCallback& error_callback) = 0;
 

diff --git a/libweave/include/weave/mock_http_client.h b/libweave/include/weave/mock_http_client.h
index 015ed0b..cb1b96e 100644
--- a/libweave/include/weave/mock_http_client.h
+++ b/libweave/include/weave/mock_http_client.h

@@ -26,27 +26,24 @@
  public:
   ~MockHttpClient() override = default;
 
-  MOCK_METHOD6(MockSendRequest,
+  MOCK_METHOD5(MockSendRequest,
                Response*(const std::string&,
                          const std::string&,
-                         const std::string&,
-                         const std::string&,
                          const Headers&,
+                         const std::string&,
                          chromeos::ErrorPtr*));
 
   std::unique_ptr<Response> SendRequestAndBlock(
       const std::string& method,
       const std::string& url,
-      const std::string& data,
-      const std::string& mime_type,
       const Headers& headers,
+      const std::string& data,
       chromeos::ErrorPtr* error) override;
 
   int SendRequest(const std::string& method,
                   const std::string& url,
-                  const std::string& data,
-                  const std::string& mime_type,
                   const Headers& headers,
+                  const std::string& data,
                   const SuccessCallback& success_callback,
                   const ErrorCallback& error_callback) override;
 };

diff --git a/libweave/src/device_registration_info.cc b/libweave/src/device_registration_info.cc
index 229ba91..8bb47c9 100644
--- a/libweave/src/device_registration_info.cc
+++ b/libweave/src/device_registration_info.cc

@@ -41,14 +41,6 @@
 
 namespace {
 
-std::pair<std::string, std::string> BuildAuthHeader(
-    const std::string& access_token_type,
-    const std::string& access_token) {
-  std::string authorization =
-      chromeos::string_utils::Join(" ", access_token_type, access_token);
-  return {"Authorization", authorization};
-}
-
 inline void SetUnexpectedError(chromeos::ErrorPtr* error) {
   chromeos::Error::AddTo(error, FROM_HERE, kErrorDomainGCD,
                          "unexpected_response", "Unexpected GCD error");
@@ -115,18 +107,18 @@
 
   std::unique_ptr<HttpClient::Response> SendAndBlock(
       chromeos::ErrorPtr* error) {
-    return transport_->SendRequestAndBlock(method_, url_, data_, mime_type_,
-                                           headers_, error);
+    return transport_->SendRequestAndBlock(method_, url_, GetFullHeaders(),
+                                           data_, error);
   }
 
   int Send(const HttpClient::SuccessCallback& success_callback,
            const HttpClient::ErrorCallback& error_callback) {
-    return transport_->SendRequest(method_, url_, data_, mime_type_, headers_,
+    return transport_->SendRequest(method_, url_, GetFullHeaders(), data_,
                                    success_callback, error_callback);
   }
 
-  void AddAuthHeader(const std::string& access_token) {
-    headers_.emplace_back(BuildAuthHeader("Bearer", access_token));
+  void SetAccessToken(const std::string& access_token) {
+    access_token_ = access_token;
   }
 
   void SetData(const std::string& data, const std::string& mime_type) {
@@ -136,22 +128,31 @@
 
   void SetFormData(
       const std::vector<std::pair<std::string, std::string>>& data) {
-    data_ = chromeos::data_encoding::WebParamsEncode(data);
-    mime_type_ = http::kWwwFormUrlEncoded;
+    SetData(chromeos::data_encoding::WebParamsEncode(data),
+            http::kWwwFormUrlEncoded);
   }
 
   void SetJsonData(const base::Value& json) {
     std::string data;
-    CHECK(base::JSONWriter::Write(json, &data_));
-    mime_type_ = http::kJsonUtf8;
+    CHECK(base::JSONWriter::Write(json, &data));
+    SetData(data, http::kJsonUtf8);
   }
 
  private:
+  HttpClient::Headers GetFullHeaders() const {
+    HttpClient::Headers headers;
+    if (!access_token_.empty())
+      headers.emplace_back(http::kAuthorization, "Bearer " + access_token_);
+    if (!mime_type_.empty())
+      headers.emplace_back(http::kContentType, mime_type_);
+    return headers;
+  }
+
   std::string method_;
   std::string url_;
   std::string data_;
   std::string mime_type_;
-  std::vector<std::pair<std::string, std::string>> headers_;
+  std::string access_token_;
   HttpClient* transport_{nullptr};
 
   DISALLOW_COPY_AND_ASSIGN(RequestSender);
@@ -676,7 +677,7 @@
 
   RequestSender sender{data->method, data->url, http_client_};
   sender.SetData(data->body, http::kJsonUtf8);
-  sender.AddAuthHeader(access_token_);
+  sender.SetAccessToken(access_token_);
   int request_id =
       sender.Send(base::Bind(&DeviceRegistrationInfo::OnCloudRequestSuccess,
                              AsWeakPtr(), data),

diff --git a/libweave/src/device_registration_info_unittest.cc b/libweave/src/device_registration_info_unittest.cc
index 72db07e..77507cd 100644
--- a/libweave/src/device_registration_info_unittest.cc
+++ b/libweave/src/device_registration_info_unittest.cc

@@ -16,6 +16,7 @@
 
 #include "libweave/src/commands/command_manager.h"
 #include "libweave/src/commands/unittest_utils.h"
+#include "libweave/src/http_constants.h"
 #include "libweave/src/states/mock_state_change_queue_interface.h"
 #include "libweave/src/states/state_manager.h"
 #include "libweave/src/storage_impls.h"
@@ -94,7 +95,7 @@
       .WillRepeatedly(Return(status_code));
   EXPECT_CALL(*response, GetContentType())
       .Times(AtLeast(1))
-      .WillRepeatedly(Return("application/json"));
+      .WillRepeatedly(Return(http::kJsonUtf8));
   EXPECT_CALL(*response, GetData())
       .Times(AtLeast(1))
       .WillRepeatedly(ReturnRefOfCopy(text));
@@ -102,8 +103,16 @@
 }
 
 std::pair<std::string, std::string> GetAuthHeader() {
-  return {std::string{"Authorization"},
-          std::string{"Bearer "} + test_data::kAccessToken};
+  return {http::kAuthorization,
+          std::string("Bearer ") + test_data::kAccessToken};
+}
+
+std::pair<std::string, std::string> GetJsonHeader() {
+  return {http::kContentType, http::kJsonUtf8};
+}
+
+std::pair<std::string, std::string> GetFormHeader() {
+  return {http::kContentType, http::kWwwFormUrlEncoded};
 }
 
 }  // anonymous namespace
@@ -229,10 +238,9 @@
   ReloadConfig();
 
   EXPECT_CALL(http_client_,
-              MockSendRequest("POST", dev_reg_->GetOAuthURL("token"), _,
-                              "application/x-www-form-urlencoded",
-                              HttpClient::Headers{}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+              MockSendRequest(http::kPost, dev_reg_->GetOAuthURL("token"),
+                              HttpClient::Headers{GetFormHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         EXPECT_EQ("refresh_token", GetFormField(data, "grant_type"));
         EXPECT_EQ(test_data::kRefreshToken,
                   GetFormField(data, "refresh_token"));
@@ -258,10 +266,9 @@
   EXPECT_EQ(RegistrationStatus::kConnecting, GetRegistrationStatus());
 
   EXPECT_CALL(http_client_,
-              MockSendRequest("POST", dev_reg_->GetOAuthURL("token"), _,
-                              "application/x-www-form-urlencoded",
-                              HttpClient::Headers{}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+              MockSendRequest(http::kPost, dev_reg_->GetOAuthURL("token"),
+                              HttpClient::Headers{GetFormHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         EXPECT_EQ("refresh_token", GetFormField(data, "grant_type"));
         EXPECT_EQ(test_data::kRefreshToken,
                   GetFormField(data, "refresh_token"));
@@ -287,10 +294,9 @@
   EXPECT_EQ(RegistrationStatus::kConnecting, GetRegistrationStatus());
 
   EXPECT_CALL(http_client_,
-              MockSendRequest("POST", dev_reg_->GetOAuthURL("token"), _,
-                              "application/x-www-form-urlencoded",
-                              HttpClient::Headers{}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+              MockSendRequest(http::kPost, dev_reg_->GetOAuthURL("token"),
+                              HttpClient::Headers{GetFormHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         EXPECT_EQ("refresh_token", GetFormField(data, "grant_type"));
         EXPECT_EQ(test_data::kRefreshToken,
                   GetFormField(data, "refresh_token"));
@@ -316,10 +322,10 @@
   SetAccessToken();
 
   EXPECT_CALL(http_client_,
-              MockSendRequest("GET", dev_reg_->GetDeviceURL(), _,
-                              "application/json; charset=utf-8",
-                              HttpClient::Headers{GetAuthHeader()}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+              MockSendRequest(
+                  http::kGet, dev_reg_->GetDeviceURL(),
+                  HttpClient::Headers{GetAuthHeader(), GetJsonHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         base::DictionaryValue json;
         json.SetString("channel.supportedType", "xmpp");
         json.SetString("deviceKind", "vendor");
@@ -385,11 +391,11 @@
 
   std::string ticket_url = dev_reg_->GetServiceURL("registrationTickets/") +
                            test_data::kClaimTicketId;
-  EXPECT_CALL(http_client_,
-              MockSendRequest(
-                  "PATCH", ticket_url + "?key=" + test_data::kApiKey, _,
-                  "application/json; charset=utf-8", HttpClient::Headers{}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+  EXPECT_CALL(
+      http_client_,
+      MockSendRequest(http::kPatch, ticket_url + "?key=" + test_data::kApiKey,
+                      HttpClient::Headers{GetJsonHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         auto json = unittests::CreateDictionaryValue(data);
         EXPECT_NE(nullptr, json.get());
         std::string value;
@@ -455,9 +461,9 @@
       })));
 
   EXPECT_CALL(http_client_,
-              MockSendRequest(
-                  "POST", ticket_url + "/finalize?key=" + test_data::kApiKey,
-                  "", _, HttpClient::Headers{}, _))
+              MockSendRequest(http::kPost, ticket_url + "/finalize?key=" +
+                                               test_data::kApiKey,
+                              HttpClient::Headers{}, _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         base::DictionaryValue json;
         json.SetString("id", test_data::kClaimTicketId);
@@ -474,10 +480,9 @@
       }));
 
   EXPECT_CALL(http_client_,
-              MockSendRequest("POST", dev_reg_->GetOAuthURL("token"), _,
-                              "application/x-www-form-urlencoded",
-                              HttpClient::Headers{}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+              MockSendRequest(http::kPost, dev_reg_->GetOAuthURL("token"),
+                              HttpClient::Headers{GetFormHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         EXPECT_EQ("authorization_code", GetFormField(data, "grant_type"));
         EXPECT_EQ(test_data::kRobotAccountAuthCode, GetFormField(data, "code"));
         EXPECT_EQ(test_data::kClientId, GetFormField(data, "client_id"));
@@ -561,10 +566,10 @@
   ASSERT_NE(nullptr, command);
 
   EXPECT_CALL(http_client_,
-              MockSendRequest("PATCH", command_url, _,
-                              "application/json; charset=utf-8",
-                              HttpClient::Headers{GetAuthHeader()}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+              MockSendRequest(
+                  http::kPatch, command_url,
+                  HttpClient::Headers{GetAuthHeader(), GetJsonHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         EXPECT_JSON_EQ(R"({"results":{"status":"Ok"}})",
                        *CreateDictionaryValue(data));
         base::DictionaryValue json;
@@ -575,16 +580,16 @@
   Mock::VerifyAndClearExpectations(&http_client_);
 
   EXPECT_CALL(http_client_,
-              MockSendRequest("PATCH", command_url, _,
-                              "application/json; charset=utf-8",
-                              HttpClient::Headers{GetAuthHeader()}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+              MockSendRequest(
+                  http::kPatch, command_url,
+                  HttpClient::Headers{GetAuthHeader(), GetJsonHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         EXPECT_JSON_EQ(R"({"state":"inProgress"})",
                        *CreateDictionaryValue(data));
         base::DictionaryValue json;
         return ReplyWithJson(200, json);
       })))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         EXPECT_JSON_EQ(R"({"progress":{"progress":18}})",
                        *CreateDictionaryValue(data));
         base::DictionaryValue json;
@@ -595,10 +600,10 @@
   Mock::VerifyAndClearExpectations(&http_client_);
 
   EXPECT_CALL(http_client_,
-              MockSendRequest("PATCH", command_url, _,
-                              "application/json; charset=utf-8",
-                              HttpClient::Headers{GetAuthHeader()}, _))
-      .WillOnce(WithArgs<2>(Invoke([](const std::string& data) {
+              MockSendRequest(
+                  http::kPatch, command_url,
+                  HttpClient::Headers{GetAuthHeader(), GetJsonHeader()}, _, _))
+      .WillOnce(WithArgs<3>(Invoke([](const std::string& data) {
         EXPECT_JSON_EQ(R"({"state":"cancelled"})",
                        *CreateDictionaryValue(data));
         base::DictionaryValue json;

diff --git a/libweave/src/mock_http_client.cc b/libweave/src/mock_http_client.cc
index d4307a4..1f223a9 100644
--- a/libweave/src/mock_http_client.cc
+++ b/libweave/src/mock_http_client.cc

@@ -13,24 +13,22 @@
 std::unique_ptr<HttpClient::Response> MockHttpClient::SendRequestAndBlock(
     const std::string& method,
     const std::string& url,
-    const std::string& data,
-    const std::string& mime_type,
     const Headers& headers,
+    const std::string& data,
     chromeos::ErrorPtr* error) {
   return std::unique_ptr<Response>{
-      MockSendRequest(method, url, data, mime_type, headers, error)};
+      MockSendRequest(method, url, headers, data, error)};
 }
 
 int MockHttpClient::SendRequest(const std::string& method,
                                 const std::string& url,
-                                const std::string& data,
-                                const std::string& mime_type,
                                 const Headers& headers,
+                                const std::string& data,
                                 const SuccessCallback& success_callback,
                                 const ErrorCallback& error_callback) {
   chromeos::ErrorPtr error;
   std::unique_ptr<Response> response{
-      MockSendRequest(method, url, data, mime_type, headers, &error)};
+      MockSendRequest(method, url, headers, data, &error)};
   if (response) {
     success_callback.Run(0, *response);
   } else {