Support chrome_to_mobile job receiving

chrome/common/cloud_print/cloud_print_helpers.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2012 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/common/cloud_print/cloud_print_helpers.h"
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
+#include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
+#include "base/sys_info.h"
 #include "base/values.h"
 #include "googleurl/src/gurl.h"
+#include "chrome/common/chrome_version_info.h"
+#include "chrome/common/cloud_print/cloud_print_consts.h"
+
+namespace {
+
+// Returns printer tags generated from |printer_tags| and the default tags
+// required by cloud print server.
+cloud_print::PrinterTags PreparePrinterTags(
+    const cloud_print::PrinterTags& printer_tags) {
+  cloud_print::PrinterTags printer_tags_out = printer_tags;
+  chrome::VersionInfo version_info;
+  DCHECK(version_info.is_valid());
+  printer_tags_out[cloud_print::kChromeVersionTagName] =
+      version_info.CreateVersionString();
+  using base::SysInfo;
+  printer_tags_out[cloud_print::kSystemNameTagName] =
+      SysInfo::OperatingSystemName();
+  printer_tags_out[cloud_print::kSystemVersionTagName] =
+      SysInfo::OperatingSystemVersion();
+  return printer_tags_out;
+}
+
+std::string HashPrinterTags(const cloud_print::PrinterTags& strings) {
+  std::string values_list;
+  cloud_print::PrinterTags::const_iterator it;
+  for (it = strings.begin(); it != strings.end(); ++it) {
+    values_list.append(it->first);
+    values_list.append(it->second);
+  }
+  return base::MD5String(values_list);
+}
+
+}  // namespace
 
 namespace cloud_print {
 
-const char kPrinterListValue[] = "printers";
-const char kSuccessValue[] = "success";
-
-// Certain cloud print requests require Chrome's X-CloudPrint-Proxy header.
-const char kChromeCloudPrintProxyHeader[] = "X-CloudPrint-Proxy: Chrome";
-
 std::string AppendPathToUrl(const GURL& url, const std::string& path) {
   DCHECK_NE(path[0], '/');
   std::string ret = url.path();
   if (url.has_path() && (ret[ret.length() - 1] != '/'))
     ret += '/';
   ret += path;
   return ret;
 }
 
 GURL GetUrlForSearch(const GURL& cloud_print_server_url) {
   std::string path(AppendPathToUrl(cloud_print_server_url, "search"));
   GURL::Replacements replacements;
   replacements.SetPathStr(path);
   return cloud_print_server_url.ReplaceComponents(replacements);
 }
 
 GURL GetUrlForSubmit(const GURL& cloud_print_server_url) {
   std::string path(AppendPathToUrl(cloud_print_server_url, "submit"));
   GURL::Replacements replacements;
   replacements.SetPathStr(path);
   return cloud_print_server_url.ReplaceComponents(replacements);
 }
 
+GURL GetUrlForPrinterList(const GURL& cloud_print_server_url,
+                          const std::string& proxy_id) {
+  std::string path(cloud_print::AppendPathToUrl(
+      cloud_print_server_url, "list"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  std::string query = StringPrintf("proxy=%s", proxy_id.c_str());
+  replacements.SetQueryStr(query);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
+GURL GetUrlForPrinterRegistration(const GURL& cloud_print_server_url) {
+  std::string path(cloud_print::AppendPathToUrl(
+      cloud_print_server_url, "register"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
+GURL GetUrlForPrinterUpdate(const GURL& cloud_print_server_url,
+                            const std::string& printer_id) {
+  std::string path(cloud_print::AppendPathToUrl(
+      cloud_print_server_url, "update"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  std::string query = StringPrintf("printerid=%s", printer_id.c_str());
+  replacements.SetQueryStr(query);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
+GURL GetUrlForPrinterDelete(const GURL& cloud_print_server_url,
+                            const std::string& printer_id,
+                            const std::string& reason) {
+  std::string path(cloud_print::AppendPathToUrl(
+      cloud_print_server_url, "delete"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  std::string query = StringPrintf(
+      "printerid=%s&reason=%s", printer_id.c_str(), reason.c_str());
+  replacements.SetQueryStr(query);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
+GURL GetUrlForJobFetch(const GURL& cloud_print_server_url,
+                       const std::string& printer_id,
+                       const std::string& reason) {
+  std::string path(cloud_print::AppendPathToUrl(
+      cloud_print_server_url, "fetch"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  std::string query = StringPrintf(
+      "printerid=%s&deb=%s", printer_id.c_str(), reason.c_str());
+  replacements.SetQueryStr(query);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
+
+GURL GetUrlForJobDelete(const GURL& cloud_print_server_url,
+                        const std::string& job_id) {
+  std::string path(cloud_print::AppendPathToUrl(
+      cloud_print_server_url, "deletejob"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  std::string query = StringPrintf("jobid=%s", job_id.c_str());
+  replacements.SetQueryStr(query);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
+GURL GetUrlForJobStatusUpdate(const GURL& cloud_print_server_url,
+                              const std::string& job_id,
+                              const std::string& status_string) {
+  std::string path(cloud_print::AppendPathToUrl(
+      cloud_print_server_url, "control"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  std::string query = StringPrintf(
+      "jobid=%s&status=%s", job_id.c_str(), status_string.c_str());
+  replacements.SetQueryStr(query);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
+GURL GetUrlForUserMessage(const GURL& cloud_print_server_url,
+                          const std::string& message_id) {
+  std::string path(
+      cloud_print::AppendPathToUrl(cloud_print_server_url, "message"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  std::string query = StringPrintf("code=%s", message_id.c_str());
+  replacements.SetQueryStr(query);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
+GURL GetUrlForGetAuthCode(const GURL& cloud_print_server_url,
+                          const std::string& oauth_client_id,
+                          const std::string& proxy_id) {
+  // We use the internal API "createrobot" instead of "getauthcode". This API
+  // will add the robot as owner to all the existing printers for this user.
+  std::string path(
+    cloud_print::AppendPathToUrl(cloud_print_server_url, "createrobot"));
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  std::string query = StringPrintf("oauth_client_id=%s&proxy=%s",
+                                    oauth_client_id.c_str(),
+                                    proxy_id.c_str());
+  replacements.SetQueryStr(query);
+  return cloud_print_server_url.ReplaceComponents(replacements);
+}
+
 bool ParseResponseJSON(const std::string& response_data,
                        bool* succeeded,
                        DictionaryValue** response_dict) {
   scoped_ptr<Value> message_value(base::JSONReader::Read(response_data));
   if (!message_value.get())
     return false;
 
   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(cloud_print::kSuccessValue, succeeded))
     *succeeded = false;
   if (response_dict)
     *response_dict = response_dict_local.release();
   return true;
 }
 
+void ParsePrinterIdsFromListResponse(const std::string& response_data,
+                                     bool* succeeded,
+                                     std::set<std::string>* printer_ids) {
+  DCHECK(succeeded);
+  DCHECK(printer_ids);
+
+  DictionaryValue* response_dict = NULL;
+  ParseResponseJSON(response_data, succeeded, &response_dict);
+  scoped_ptr<DictionaryValue> response_dict_to_be_released(response_dict);
+
+  if (!(*succeeded) || !response_dict) {
+    printer_ids->clear();
+    return;
+  }
+
+  const ListValue* printer_list = NULL;
+  if (!response_dict->GetList(kPrinterListValue, &printer_list) ||
+      !printer_list) {
+    printer_ids->clear();
+    return;
+  }
+
+  for (size_t index = 0; index < printer_list->GetSize(); ++index) {
+    // Parse the printer id from the printer data.
+    const DictionaryValue* printer_data = NULL;
+    if (!printer_list->GetDictionary(index, &printer_data) || !printer_data)
+      continue;
+    std::string printer_id;
+    if (printer_data->GetString(kIdValue, &printer_id) && !printer_id.empty())
+      printer_ids->insert(printer_id);
+  }
+}
+
+void ParsePrinterIdFromRegisterResponse(const std::string& response_data,
+                                        bool* succeeded,
+                                        std::string* printer_id) {
+  DCHECK(succeeded);
+  DCHECK(printer_id);
+
+  DictionaryValue* response_dict = NULL;
+  ParseResponseJSON(response_data, succeeded, &response_dict);
+  scoped_ptr<DictionaryValue> response_dict_to_be_released(response_dict);
+
+  if (!(*succeeded) || !response_dict) {
+    printer_id->clear();
+    return;
+  }
+
+  const base::ListValue* printer_list = NULL;
+  if (!response_dict->GetList(cloud_print::kPrinterListValue, &printer_list) ||
+      !printer_list ||
+      printer_list->GetSize() != 1) {
+    printer_id->clear();
+    return;
+  }
+
+  const DictionaryValue* printer_data = NULL;
+  if (!printer_list->GetDictionary(0, &printer_data) || !printer_data) {
+    printer_id->clear();
+    return;
+  }
+
+  if (!printer_data->GetString(kIdValue, printer_id))
+    printer_id->clear();
+}
+
 void 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()));
   if (!content_type.empty()) {
     // If Content-type is specified, the next line is that
     post_data->append(StringPrintf("Content-Type: %s\r\n",
                       content_type.c_str()));
   }
   // Leave an empty line and append the value.
   post_data->append(StringPrintf("\r\n%s\r\n", value.c_str()));
 }
 
+std::string GetMultipartMimeType(const std::string& mime_boundary) {
+  return std::string("multipart/form-data; boundary=") += mime_boundary;
+}
+
 // Create a MIME boundary marker (27 '-' characters followed by 16 hex digits).
 void CreateMimeBoundaryForUpload(std::string* out) {
   int r1 = base::RandInt(0, kint32max);
   int r2 = base::RandInt(0, kint32max);
   base::SStringPrintf(out, "---------------------------%08X%08X", r1, r2);
 }
 
+std::string GetHashOfPrinterTags(const PrinterTags& printer_tags) {
+  PrinterTags printer_tags_prepared = PreparePrinterTags(printer_tags);
+  std::string values_list;
+  for (PrinterTags::const_iterator it = printer_tags_prepared.begin();
+      it != printer_tags_prepared.end(); ++it) {
+    values_list.append(it->first);
+    values_list.append(it->second);
+  }
+  return base::MD5String(values_list);
+}
+
+std::string GetPostDataForPrinterTags(
+    const PrinterTags& printer_tags,
+    const std::string& mime_boundary,
+    const std::string& proxy_tag_prefix,
+    const std::string& tags_hash_tag_name) {
+  PrinterTags printer_tags_prepared = PreparePrinterTags(printer_tags);
+  std::string post_data;
+  for (PrinterTags::const_iterator it = printer_tags.begin();
+      it != printer_tags.end(); ++it) {
+    // TODO(gene) Escape '=' char from name. Warning for now.
+    if (it->first.find('=') != std::string::npos) {
+      LOG(WARNING) <<
+          "CP_PROXY: Printer option name contains '=' character";
+      NOTREACHED();
+    }
+    // All our tags have a special prefix to identify them as such.
+    std::string msg(proxy_tag_prefix);
+    msg += it->first;
+    msg += "=";
+    msg += it->second;
+    cloud_print::AddMultipartValueForUpload(cloud_print::kPrinterTagValue, msg,
+        mime_boundary, std::string(), &post_data);
+  }
+  std::string tags_hash_msg(tags_hash_tag_name);
+  tags_hash_msg += "=";
+  tags_hash_msg += HashPrinterTags(printer_tags);
+  cloud_print::AddMultipartValueForUpload(cloud_print::kPrinterTagValue,
+                                          tags_hash_msg,
+                                          mime_boundary, std::string(),
+                                          &post_data);
+  return post_data;
+}
+
 }  // namespace cloud_print