Adding the Copresence RpcHandler and HttpPost helper.

components/copresence/rpc/http_post.h

Index: components/copresence/rpc/http_post.h
diff --git a/components/copresence/rpc/http_post.h b/components/copresence/rpc/http_post.h
new file mode 100644
index 0000000000000000000000000000000000000000..33df7a69b84c826f4b7eee4e6b1e52bbbd587687
--- /dev/null
+++ b/components/copresence/rpc/http_post.h
@@ -0,0 +1,69 @@
+// 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.
+
+#ifndef COMPONENTS_COPRESENCE_RPC_HTTP_POST_H_
+#define COMPONENTS_COPRESENCE_RPC_HTTP_POST_H_
+
+#include <string>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "net/url_request/url_fetcher_delegate.h"
+
+namespace google {
+namespace protobuf {
+class MessageLite;
+}
+}
+
+namespace net {
+class URLRequestContextGetter;
+}
+
+namespace copresence {
+
+// This class handles all Apiary calls to the Copresence server.
+// It configures the HTTP request appropriately and reports any errors.
+// Clients should not attempt to delete this class, as it needs to
+// persist until the HTTP request completes (or times out).
+//
+// TODO(ckehoe): Add retry logic.
+class HttpPost : public net::URLFetcherDelegate,
+                 public base::SupportsWeakPtr<HttpPost> {
+ public:
+  // Callback to receive the HTTP status code and body of the response (if any).
+  typedef base::Callback<void(int, const std::string&)> ResponseCallback;
+
+  // An id for testing url fetching.
+  static const int kUrlFetcherId = 1;
+
+  // Send a request to the Copresence server. After calling the callback, this
+  // object will delete itself. |url_context_getter| is owned by the caller,
+  // and must be valid until the request is actually sent (on the IO thread).
+  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);
+
+ private:
+  // This class deletes itself when the request completes (or times out).
+  // TODO(ckehoe): Self-deletion is a possible source of memory leaks.

[willchan no longer on Chromium, 2014/08/06 23:57:39]

During profile shutdown, all the network objects that the
URLRequestContextGetter points to will be deleted. If the callback gets invoked
during shutdown, we now have use after frees, which can be a security hole. I
don't think you can leave this as a TODO.

[Charlie, 2014/08/07 00:08:24]

Ok. Before I write the code, can you confirm if this solution will work?

1. Don't have HttpPost self-delete. Instead, it is owned by (the persistent)
RpcHandler, which is the only one who will care about HTTP responses anyway.
2. Pass the HttpPost as a WeakPtr<net::URLFetcherDelegate>. Then if the callback
is invoked during shutdown, it will just be ignored.

[willchan no longer on Chromium, 2014/08/07 00:11:40]

Sorry, I just got started with the review. But I saw that and immediately sent a
comment. I don't know how this code fits in, so I need to read up more before I
can advise you how best to fix this. But basically, you need to make sure that
when profiles and the browser process shutdown, they cancel all URLFetchers that
they own. I don't know what owns this network request, so I need to go read this
component. It'll take awhile.

[rkc, 2014/08/07 00:18:20]

I would assume this is what you'd do?
1.) Keep a vector of HTTP posts created by the rpc handler in the handler that
creates it. 
2.) Rename DisconnectFromWhispernet() to Shutdown(). This method will get called
before a profile destructs. In the Shutdown method, disconnect from whispernet
as usual, and also delete all our http posts. Once deleted, we don't have to
worry about the callback.

I am not sure why the HttpPost needs to be a WeakPtr.

+  //               Re-think the lifecycle management here.
+  virtual ~HttpPost();
+
+  // Overridden from net::URLFetcherDelegate.
+  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
+
+  ResponseCallback response_callback_;
+  scoped_ptr<net::URLFetcher> url_fetcher_;
+
+  DISALLOW_COPY_AND_ASSIGN(HttpPost);
+};
+
+}  // namespace copresence
+
+#endif  // COMPONENTS_COPRESENCE_RPC_HTTP_POST_H_