Adding the Copresence RpcHandler and HttpPost helper.

components/copresence/rpc/http_post.cc

+// Copyright 2014 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/copresence/rpc/http_post.h"
+
+#include <google/protobuf/message_lite.h>
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "components/copresence/copresence_switches.h"
+#include "content/public/browser/browser_context.h"
+#include "google_apis/google_api_keys.h"
+#include "net/base/load_flags.h"
+#include "net/base/url_util.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_request_context_getter.h"
+
+namespace copresence {
+
+namespace {
+
+const char kTracingTokenField[] = "trace";
+const char kApiKeyField[] = "key";
+
+}  // namespace
+
+HttpPost::HttpPost(net::URLRequestContextGetter* url_context_getter,
+                   const std::string& server_host,
+                   const std::string& rpc_name,
+                   const google::protobuf::MessageLite& request_proto,
+                   const ResponseCallback& response_callback)
+                   : response_callback_(response_callback) {
+  // Create the base URL to call.
+  GURL url(server_host + "/" + rpc_name);
+
+  // Add the Chrome API key.
+  // TODO(ckehoe): Replace this with an app-specific key
+  //               once the server API supports it.
+  DCHECK(google_apis::HasKeysConfigured());
+  url = net::AppendQueryParameter(url, kApiKeyField, google_apis::GetAPIKey());
+
+  // Add the tracing token, if specified.
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kCopresenceTracingToken)) {
+    url = net::AppendQueryParameter(
+        url,
+        kTracingTokenField,
+        "token:" + command_line->GetSwitchValueASCII(
+            switches::kCopresenceTracingToken));
+  }
+
+  // Serialize the proto for transmission.
+  std::string request_data;
+  DCHECK(request_proto.SerializeToString(&request_data));
+
+  // Configure and send the request.
+  url_fetcher_.reset(net::URLFetcher::Create(
+      kUrlFetcherId, url, net::URLFetcher::POST, this));
+  url_fetcher_->SetRequestContext(url_context_getter);
+  url_fetcher_->SetLoadFlags(net::LOAD_BYPASS_CACHE |
+                             net::LOAD_DISABLE_CACHE |
+                             net::LOAD_DO_NOT_SAVE_COOKIES |
+                             net::LOAD_DO_NOT_SEND_COOKIES |
+                             net::LOAD_DO_NOT_SEND_AUTH_DATA);
+  url_fetcher_->SetUploadData("application/x-protobuf", request_data);
+  url_fetcher_->Start();
+}
+
+HttpPost::~HttpPost() {}
+
+void HttpPost::Cancel() {
+  // This deletes the url_fetcher_, which aborts the request.

[rkc, 2014/08/07 18:01:04]

Nit: The comment is not necessary :)

[Charlie, 2014/08/07 18:05:01]

Technically no comments are necessary unless the style guide explicitly requires
them. But this is clearer. If it were really so obvious, we would all have seen
the problem before Will pointed it out.

[rkc, 2014/08/07 19:25:06]

It's a nit so feel free to address it how you want.

[willchan no longer on Chromium, 2014/08/07 20:27:05]

It's a little odd that HttpPost::Cancel() does `delete this;`

Why not just have the owner (the RpcHandler?) delete the HttpPost?

[Charlie, 2014/08/07 22:40:58]

Notice that the HttpPost destructor is private. If we're counting on this object
deleting itself, we want to have explicit control over deletion. Having this
method in the API forces deletion to be explicit - i.e. the HttpPost cannot just
be allowed to go out of scope.

[willchan no longer on Chromium, 2014/08/07 22:47:52]

But isn't this weird? This sounds like:

class Foo {
 private:
  void MyPrivateFunction() { ... }

 public:
  void SecretAccessToMyPrivateFunction() { MyPrivateFunction(); }
};

Replace MyPrivateFunction with the destructor, and
SecretAccessToMyPrivateFunction() with Cancel().

Generally speaking, if Foo is able to delete Bar, then Foo probably owns Bar.
And if you want to keep ownership clean, then you probably want Foo to be the
only thing that deletes Bar. And not to allow Bar to delete itself.

[Charlie, 2014/08/07 23:33:04]

I guess that makes sense. If HttpPost deletes itself, it should be the only
thing that deletes itself. And if not, someone else should have the sole
responsibility.

Fixed.

+  delete this;
+}
+
+void HttpPost::OnURLFetchComplete(const net::URLFetcher* source) {
+  DCHECK_EQ(url_fetcher_.get(), source);
+
+  // Gather response info.
+  std::string response;
+  source->GetResponseAsString(&response);
+  int response_code = source->GetResponseCode();
+
+  // Log any errors.
+  if (response_code < 0) {
+    LOG(ERROR) << "Couldn't contact the Copresence server at "
+               << source->GetURL();
+  } else if (response_code != net::HTTP_OK) {
+    LOG(ERROR) << "Copresence request got HTTP response code " << response_code
+               << ". Response:\n" << response;
+  }
+
+  // Return the response.
+  response_callback_.Run(response_code, response, this);
+  delete this;
+}
+
+}  // namespace copresence