Adding the Copresence RpcHandler and HttpPost helper.

components/copresence/copresence_client.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/public/copresence_client.h"
 
 #include "base/bind.h"
 #include "components/copresence/public/copresence_client_delegate.h"
 #include "components/copresence/public/whispernet_client.h"
 #include "components/copresence/rpc/rpc_handler.h"
 
 namespace copresence {
 
 PendingRequest::PendingRequest(const copresence::ReportRequest& report,
                                const std::string app_id,
                                const StatusCallback& callback)
     : report(report), app_id(app_id), callback(callback) {
 }
 
 PendingRequest::~PendingRequest() {
 }
 
 // Public methods
 
 CopresenceClient::CopresenceClient(CopresenceClientDelegate* delegate)
     : delegate_(delegate), init_failed_(false), pending_init_operations_(0) {
   DVLOG(3) << "Initializing client.";
   pending_init_operations_++;
-  rpc_handler_.reset(
-      new RpcHandler(delegate,
-                     base::Bind(&CopresenceClient::InitStepComplete,
-                                AsWeakPtr(),
-                                "Copresence device registration")));
+  rpc_handler_.reset(new RpcHandler(delegate));
+  rpc_handler_->Initialize(base::Bind(&CopresenceClient::InitStepComplete,
+                                      AsWeakPtr(),

[willchan no longer on Chromium, 2014/08/07 20:42:43]

Why is AsWeakPtr() used here? Doesn't CopresenceClient own rpc_handler_? I
assume so, since it uses a scoped_ptr<RpcHandler>. If I'm correct, then why is a
weak pointer necessary? Whenever the CopresenceClient gets deleted, it will
delete RpcHandler.

Using WeakPtrs like this just makes users ask more questions about the lifetime
of the various objects. What owns what?

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

Removed.

+                                      "Copresence device registration"));
 
   pending_init_operations_++;
   delegate_->GetWhispernetClient()->Initialize(
       base::Bind(&CopresenceClient::InitStepComplete,
                  AsWeakPtr(),
                  "Whispernet proxy initialization"));
 }
 
 CopresenceClient::~CopresenceClient() {
 }
 
 void CopresenceClient::Shutdown() {
   DVLOG(3) << "Shutting down client.";
   delegate_->GetWhispernetClient()->Shutdown();

[willchan no longer on Chromium, 2014/08/07 20:42:43]

Who's the delegate of CopresenceClient? Who is calling
CopresenceClient::Shutdown()? Are they the same entity? If not, what's the
lifetime relationship between them? Why is there a Shutdown() in the first
place? Why not just delete CopresenceClient?

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

Addressed by Rahul?

   rpc_handler_->DisconnectFromWhispernet();
 }
 
 // Returns false if any operations were malformed.
 void CopresenceClient::ExecuteReportRequest(copresence::ReportRequest request,
                                             const std::string& app_id,
                                             const StatusCallback& callback) {
   // Don't take on any more requests, we can't execute any, init failed.
   if (init_failed_) {
     callback.Run(FAIL);
@@ skipping 11 matching lines @@
   }
 }
 
 // Private methods
 
 void CopresenceClient::CompleteInitialization() {
   if (pending_init_operations_)
     return;
 
   if (!init_failed_)
-    rpc_handler_->ConnectToWhispernet(delegate_->GetWhispernetClient());
+    rpc_handler_->ConnectToWhispernet();
 
   for (std::vector<PendingRequest>::iterator request =
            pending_requests_queue_.begin();
        request != pending_requests_queue_.end();
        ++request) {
     if (init_failed_) {
       request->callback.Run(FAIL);
     } else {
       rpc_handler_->SendReportRequest(
           make_scoped_ptr(new copresence::ReportRequest(request->report)),
           request->app_id,
           request->callback);
     }
   }
   pending_requests_queue_.clear();
 }
 
 void CopresenceClient::InitStepComplete(const std::string& step, bool success) {
   if (!success) {
     LOG(ERROR) << step << " failed!";
     init_failed_ = true;
   }
 
   DVLOG(3) << "Init step: " << step << " complete.";
   pending_init_operations_--;
   CompleteInitialization();
 }
 
 }  // namespace copresence