Re-landing issue 4202006 (http://codereview.chromium.org/4202006/show) which ...

chrome/service/cloud_print/cloud_print_helpers.cc

 // Copyright (c) 2010 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/service/cloud_print/cloud_print_helpers.h"
 
 #include "base/json/json_reader.h"
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/service/cloud_print/cloud_print_consts.h"
 #include "chrome/common/net/url_fetcher.h"
-#include "chrome/service/net/service_url_request_context.h"
 #include "chrome/service/service_process.h"
 
 std::string StringFromJobStatus(cloud_print::PrintJobStatus status) {
   std::string ret;
   switch (status) {
     case cloud_print::PRINT_JOB_STATUS_IN_PROGRESS:
       ret = "in_progress";
       break;
     case cloud_print::PRINT_JOB_STATUS_ERROR:
       ret = "error";
@@ skipping 103 matching lines @@
                    details.total_pages,
                    details.pages_printed);
   replacements.SetQueryStr(query);
   return cloud_print_server_url.ReplaceComponents(replacements);
 }
 
 bool CloudPrintHelpers::ParseResponseJSON(
     const std::string& response_data, bool* succeeded,
     DictionaryValue** response_dict) {
   scoped_ptr<Value> message_value(base::JSONReader::Read(response_data, false));
-  if (!message_value.get()) {
-    NOTREACHED();
+  if (!message_value.get())
     return false;
-  }
-  if (!message_value->IsType(Value::TYPE_DICTIONARY)) {
-    NOTREACHED();
+
+  if (!message_value->IsType(Value::TYPE_DICTIONARY))
     return false;
-  }
+
   scoped_ptr<DictionaryValue> response_dict_local(
       static_cast<DictionaryValue*>(message_value.release()));
   if (succeeded)
     response_dict_local->GetBoolean(kSuccessValue, succeeded);
   if (response_dict)
     *response_dict = response_dict_local.release();
   return true;
 }
 
-void CloudPrintHelpers::PrepCloudPrintRequest(URLFetcher* request,
-                                              const std::string& auth_token) {
-  DCHECK(g_service_process);
-  request->set_request_context(new ServiceURLRequestContextGetter());
-  std::string headers = "Authorization: GoogleLogin auth=";
-  headers += auth_token;
-  headers += "\r\n";
-  headers += kChromeCloudPrintProxyHeader;
-  request->set_extra_request_headers(headers);
-}
-
-void CloudPrintHelpers::HandleServerError(int* error_count, int max_retry_count,
-                                          int64 max_retry_interval,
-                                          int64 base_retry_interval,
-                                          Task* task_to_retry,
-                                          Task* task_on_give_up) {
-  (*error_count)++;
-  if ((-1 != max_retry_count) && (*error_count > max_retry_count)) {
-    if (task_on_give_up) {
-      MessageLoop::current()->PostTask(FROM_HERE, task_on_give_up);
-    }
-  } else {
-    int64 retry_interval = base_retry_interval * (*error_count);
-    if ((-1 != max_retry_interval) && (retry_interval > max_retry_interval)) {
-      retry_interval = max_retry_interval;
-    }
-    MessageLoop::current()->PostDelayedTask(FROM_HERE, task_to_retry,
-        retry_interval);
-  }
-}
-
 void CloudPrintHelpers::AddMultipartValueForUpload(
     const std::string& value_name, const std::string& value,
     const std::string& mime_boundary, const std::string& content_type,
     std::string* post_data) {
   DCHECK(post_data);
   // First line is the boundary
   post_data->append("--" + mime_boundary + "\r\n");
   // Next line is the Content-disposition
   post_data->append(StringPrintf("Content-Disposition: form-data; "
                    "name=\"%s\"\r\n", value_name.c_str()));
@@ skipping 55 matching lines @@
                                std::string(), post_data);
   }
   std::string tags_hash = MD5String(tags_list);
   std::string tags_hash_msg(kTagsHashTagName);
   tags_hash_msg += "=";
   tags_hash_msg += tags_hash;
   AddMultipartValueForUpload(kPrinterTagValue, tags_hash_msg, mime_boundary,
                              std::string(), post_data);
 }