Actual cancelation of registration when cancel buttons pressed

chrome/browser/local_discovery/privet_http_impl.cc

 // Copyright 2013 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 "chrome/browser/local_discovery/privet_http_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/local_discovery/privet_constants.h"
 #include "url/gurl.h"
 
 namespace local_discovery {
 
 namespace {
 // First format argument (string) is the host, second format argument (int) is
 // the port.
 const char kPrivetInfoURLFormat[] = "http://%s:%d/privet/info";
 // First format argument (string) is the host, second format argument (int) is
 // the port, third argument (string) is the action name, fourth argument
 // (string) is the user name.
 const char kPrivetRegisterURLFormat[] =
     "http://%s:%d/privet/register?action=%s&user=%s";
+
+const int kPrivetCancelationTimeoutSeconds = 3;
 }  // namespace
 
 PrivetInfoOperationImpl::PrivetInfoOperationImpl(
     PrivetHTTPClientImpl* privet_client,
     PrivetInfoOperation::Delegate* delegate)
     : privet_client_(privet_client), delegate_(delegate) {
 }
 
 PrivetInfoOperationImpl::~PrivetInfoOperationImpl() {
 }
@@ skipping 50 matching lines @@
 
   ongoing_ = true;
   next_response_handler_ =
       base::Bind(&PrivetRegisterOperationImpl::StartResponse,
                  base::Unretained(this));
   SendRequest(kPrivetActionStart);
 }
 
 void PrivetRegisterOperationImpl::Cancel() {
   url_fetcher_.reset();
-  // TODO(noamsml): Proper cancelation.
+
+  if (ongoing_) {
+    // Owned by the message loop.
+    Cancelation* cancelation = new Cancelation(privet_client_, user_);
+
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&PrivetRegisterOperationImpl::Cancelation::Cleanup,
+                   base::Owned(cancelation)),
+        base::TimeDelta::FromSeconds(kPrivetCancelationTimeoutSeconds));
+
+    ongoing_ = false;
+  }
 }
 
 void PrivetRegisterOperationImpl::CompleteRegistration() {
   next_response_handler_ =
       base::Bind(&PrivetRegisterOperationImpl::CompleteResponse,
                  base::Unretained(this));
   SendRequest(kPrivetActionComplete);
 }
 
 PrivetHTTPClient* PrivetRegisterOperationImpl::GetHTTPClient() {
@@ skipping 63 matching lines @@
     return;
   }
 
   // TODO(noamsml): Match the user&action with the user&action in the object,
   // and fail if different.
 
   next_response_handler_.Run(*value);
 }
 
 void PrivetRegisterOperationImpl::SendRequest(const std::string& action) {
-  std::string url = base::StringPrintf(
-      kPrivetRegisterURLFormat,
-      privet_client_->host_port().host().c_str(),
-      privet_client_->host_port().port(),
-      action.c_str(),
-      user_.c_str());
+  GURL url = GetURLForActionAndUser(privet_client_, action, user_);
 
   current_action_ = action;
   url_fetcher_ = privet_client_->fetcher_factory().CreateURLFetcher(
-      GURL(url), net::URLFetcher::POST, this);
+      url, net::URLFetcher::POST, this);
   url_fetcher_->Start();
 }
 
 void PrivetRegisterOperationImpl::StartResponse(
     const base::DictionaryValue& value) {
   next_response_handler_ =
       base::Bind(&PrivetRegisterOperationImpl::GetClaimTokenResponse,
                  base::Unretained(this));
 
   SendRequest(kPrivetActionGetClaimToken);
@@ skipping 70 matching lines @@
   info_operation_ = privet_client_->CreateInfoOperation(this);
   info_operation_->Start();
 }
 
 bool PrivetRegisterOperationImpl::PrivetErrorTransient(
     const std::string& error) {
   return (error == kPrivetErrorDeviceBusy) ||
          (error == kPrivetErrorPendingUserAction);
 }
 
+// static
+GURL PrivetRegisterOperationImpl::GetURLForActionAndUser(
+    PrivetHTTPClientImpl* privet_client,
+    const std::string& action,
+    const std::string& user) {
+  return GURL(base::StringPrintf(kPrivetRegisterURLFormat,
+                                 privet_client->host_port().host().c_str(),
+                                 privet_client->host_port().port(),
+                                 action.c_str(),
+                                 user.c_str()));
+}
+
+PrivetRegisterOperationImpl::Cancelation::Cancelation(
+    PrivetHTTPClientImpl* privet_client,
+    const std::string& user) {
+  GURL url = GetURLForActionAndUser(privet_client,
+                                    kPrivetActionCancel,
+                                    user);
+  url_fetcher_ = privet_client->fetcher_factory().CreateURLFetcher(
+      url, net::URLFetcher::POST, this);
+  url_fetcher_->Start();
+}
+
+PrivetRegisterOperationImpl::Cancelation::~Cancelation() {
+}
+
+void PrivetRegisterOperationImpl::Cancelation::OnError(
+    PrivetURLFetcher* fetcher,
+    PrivetURLFetcher::ErrorType error) {
+}
+
+void PrivetRegisterOperationImpl::Cancelation::OnParsedJson(
+    PrivetURLFetcher* fetcher,
+    const base::DictionaryValue* value,
+    bool has_error) {
+}
+
+void PrivetRegisterOperationImpl::Cancelation::Cleanup() {
+  // Nothing needs to be done, as base::Owned will delete this object,
+  // this callback is just here to pass ownership of the Cancelation to
+  // the message loop.
+}
+
 PrivetHTTPClientImpl::PrivetHTTPClientImpl(
     const std::string& name,
     const net::HostPortPair& host_port,
     net::URLRequestContextGetter* request_context)
     : name_(name),
       fetcher_factory_(request_context),
       host_port_(host_port) {
 }
 
 PrivetHTTPClientImpl::~PrivetHTTPClientImpl() {
@@ skipping 23 matching lines @@
 
 void PrivetHTTPClientImpl::CacheInfo(const base::DictionaryValue* cached_info) {
   cached_info_.reset(cached_info->DeepCopy());
   std::string token;
   if (cached_info_->GetString(kPrivetInfoKeyToken, &token)) {
     fetcher_factory_.set_token(token);
   }
 }
 
 }  // namespace local_discovery