Small: Use WebBase64/UrlBase64 encoding for requests sent to the server.

components/safe_browsing_db/v4_update_protocol_manager.cc

 // Copyright 2016 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 "components/safe_browsing_db/v4_update_protocol_manager.h"
 
 #include <utility>
 
-#include "base/base64.h"
+#include "base/base64url.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/timer/timer.h"
 #include "components/safe_browsing_db/safebrowsing.pb.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 164 matching lines @@
     base::TimeDelta interval) {
   DCHECK(CalledOnValidThread());
   DCHECK(interval >= base::TimeDelta());
 
   // Unschedule any current timer.
   update_timer_.Stop();
   update_timer_.Start(FROM_HERE, interval, this,
                       &V4UpdateProtocolManager::IssueUpdateRequest);
 }
 
 // static

[Nathan Parker, 2016/06/22 17:24:05]

nit: I feel like the longer name doesn't add much value -- if you want to know
the details of how it's encoded, you should read the code or the function
comments.

[vakh (use Gerrit instead), 2016/06/22 20:57:02]

Done.

-std::string V4UpdateProtocolManager::GetBase64SerializedUpdateRequestProto(
+std::string V4UpdateProtocolManager::GetWebBase64SerializedUpdateRequestProto(
     const StoreStateMap* store_state_map) {
   // Build the request. Client info and client states are not added to the
   // request protocol buffer. Client info is passed as params in the url.
   FetchThreatListUpdatesRequest request;
   for (const auto& entry : *store_state_map) {
     const auto& list_to_update = entry.first;
     const auto& state = entry.second;
     ListUpdateRequest* list_update_request = request.add_list_update_requests();
     list_update_request->set_platform_type(list_to_update.platform_type);
     list_update_request->set_threat_entry_type(
         list_to_update.threat_entry_type);
     list_update_request->set_threat_type(list_to_update.threat_type);
 
     if (!state.empty()) {
       list_update_request->set_state(state);
     }
   }
 
   // Serialize and Base64 encode.
   std::string req_data, req_base64;
   request.SerializeToString(&req_data);
-  base::Base64Encode(req_data, &req_base64);
-
+  base::Base64UrlEncode(req_data, base::Base64UrlEncodePolicy::INCLUDE_PADDING,

[Nathan Parker, 2016/06/22 17:24:05]

Does this affect any test?  Should it?

[vakh (use Gerrit instead), 2016/06/22 20:57:03]

Done.
Added a test for the '-' and for the '_' cases.

+                        &req_base64);
   return req_base64;
 }
 
 bool V4UpdateProtocolManager::ParseUpdateResponse(
     const std::string& data,
     std::vector<ListUpdateResponse>* list_update_responses) {
   FetchThreatListUpdatesResponse response;
 
   if (!response.ParseFromString(data)) {
     RecordParseUpdateResult(PARSE_FROM_STRING_ERROR);
@@ skipping 34 matching lines @@
 void V4UpdateProtocolManager::IssueUpdateRequest() {
   DCHECK(CalledOnValidThread());
 
   // If an update request is already pending, record and return silently.
   if (request_.get()) {
     RecordUpdateResult(V4OperationResult::ALREADY_PENDING_ERROR);
     return;
   }
 
   std::string req_base64 =
-      GetBase64SerializedUpdateRequestProto(store_state_map_.get());
+      GetWebBase64SerializedUpdateRequestProto(store_state_map_.get());
   GURL update_url;
   net::HttpRequestHeaders headers;
   GetUpdateUrlAndHeaders(req_base64, &update_url, &headers);
 
   std::unique_ptr<net::URLFetcher> fetcher = net::URLFetcher::Create(
       url_fetcher_id_++, update_url, net::URLFetcher::GET, this);
   fetcher->SetExtraRequestHeaders(headers.ToString());
 
   request_.reset(fetcher.release());
 
@@ skipping 57 matching lines @@
 
 void V4UpdateProtocolManager::GetUpdateUrlAndHeaders(
     const std::string& req_base64,
     GURL* gurl,
     net::HttpRequestHeaders* headers) const {
   V4ProtocolManagerUtil::GetRequestUrlAndHeaders(
       req_base64, "threatListUpdates:fetch", config_, gurl, headers);
 }
 
 }  // namespace safe_browsing