Merge 145197 - clean-up: Use an id instead of memory pointer string in webui.

chrome/browser/ui/webui/options2/certificate_manager_handler2.cc

 // Copyright (c) 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/browser/ui/webui/options2/certificate_manager_handler2.h"
 
+#include <algorithm>
+#include <map>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"  // for FileAccessProvider
+#include "base/id_map.h"
 #include "base/memory/scoped_vector.h"
 #include "base/safe_strerror_posix.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/certificate_viewer.h"
 #include "chrome/browser/ui/certificate_dialogs.h"
 #include "chrome/browser/ui/crypto_module_password_dialog.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 25 matching lines @@
 
 // Enumeration of different callers of SelectFile.  (Start counting at 1 so
 // if SelectFile is accidentally called with params=NULL it won't match any.)
 enum {
   EXPORT_PERSONAL_FILE_SELECTED = 1,
   IMPORT_PERSONAL_FILE_SELECTED,
   IMPORT_SERVER_FILE_SELECTED,
   IMPORT_CA_FILE_SELECTED,
 };
 
-// TODO(mattm): These are duplicated from cookies_view_handler.cc
-// Encodes a pointer value into a hex string.
-std::string PointerToHexString(const void* pointer) {
-  return base::HexEncode(&pointer, sizeof(pointer));
-}
-
-// Decodes a pointer from a hex string.
-void* HexStringToPointer(const std::string& str) {
-  std::vector<uint8> buffer;
-  if (!base::HexStringToBytes(str, &buffer) ||
-      buffer.size() != sizeof(void*)) {
-    return NULL;
-  }
-
-  return *reinterpret_cast<void**>(&buffer[0]);
-}
-
 std::string OrgNameToId(const std::string& org) {
   return "org-" + org;
 }
 
-std::string CertToId(const net::X509Certificate& cert) {
-  return "cert-" + PointerToHexString(&cert);
-}
-
-net::X509Certificate* IdToCert(const std::string& id) {
-  if (!StartsWithASCII(id, "cert-", true))
-    return NULL;
-  return reinterpret_cast<net::X509Certificate*>(
-      HexStringToPointer(id.substr(5)));
-}
-
-net::X509Certificate* CallbackArgsToCert(const ListValue* args) {
-  std::string node_id;
-  if (!args->GetString(0, &node_id)){
-    return NULL;
-  }
-  net::X509Certificate* cert = IdToCert(node_id);
-  if (!cert) {
-    NOTREACHED();
-    return NULL;
-  }
-  return cert;
-}
-
 bool CallbackArgsToBool(const ListValue* args, int index, bool* result) {
   std::string string_value;
   if (!args->GetString(index, &string_value))
     return false;
 
   *result = string_value[0] == 't';
   return true;
 }
 
 struct DictionaryIdComparator {
@@ skipping 31 matching lines @@
     default:
       return l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR);
   }
 }
 
 }  // namespace
 
 namespace options2 {
 
 ///////////////////////////////////////////////////////////////////////////////
+//  CertIdMap
+
+class CertIdMap {
+ public:
+  CertIdMap() {}
+  ~CertIdMap() {}
+
+  std::string CertToId(net::X509Certificate* cert);
+  net::X509Certificate* IdToCert(const std::string& id);
+  net::X509Certificate* CallbackArgsToCert(const base::ListValue* args);
+
+ private:
+  typedef std::map<net::X509Certificate*, int32> CertMap;
+
+  // Creates an ID for cert and looks up the cert for an ID.
+  IDMap<net::X509Certificate>id_map_;
+
+  // Finds the ID for a cert.
+  CertMap cert_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(CertIdMap);
+};
+
+std::string CertIdMap::CertToId(net::X509Certificate* cert) {
+  CertMap::const_iterator iter = cert_map_.find(cert);
+  if (iter != cert_map_.end())
+    return base::IntToString(iter->second);
+
+  int32 new_id = id_map_.Add(cert);
+  cert_map_[cert] = new_id;
+  return base::IntToString(new_id);
+}
+
+net::X509Certificate* CertIdMap::IdToCert(const std::string& id) {
+  int32 cert_id = 0;
+  if (!base::StringToInt(id, &cert_id))
+    return NULL;
+
+  return id_map_.Lookup(cert_id);
+}
+
+net::X509Certificate* CertIdMap::CallbackArgsToCert(
+    const ListValue* args) {
+  std::string node_id;
+  if (!args->GetString(0, &node_id))
+    return NULL;
+
+  net::X509Certificate* cert = IdToCert(node_id);
+  if (!cert) {
+    NOTREACHED();
+    return NULL;
+  }
+
+  return cert;
+}
+
+///////////////////////////////////////////////////////////////////////////////
 //  FileAccessProvider
 
 // TODO(mattm): Move to some shared location?
 class FileAccessProvider
     : public base::RefCountedThreadSafe<FileAccessProvider>,
       public CancelableRequestProvider {
  public:
   // Reports 0 on success or errno on failure, and the data of the file upon
   // success.
   // TODO(mattm): don't pass std::string by value.. could use RefCountedBytes
@@ skipping 86 matching lines @@
     return;
 
   request->ForwardResult(saved_errno, bytes_written);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //  CertificateManagerHandler
 
 CertificateManagerHandler::CertificateManagerHandler()
     : file_access_provider_(new FileAccessProvider()),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
+      cert_id_map_(new CertIdMap) {
   certificate_manager_model_.reset(new CertificateManagerModel(this));
 }
 
 CertificateManagerHandler::~CertificateManagerHandler() {
 }
 
 void CertificateManagerHandler::GetLocalizedValues(
     DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
@@ skipping 215 matching lines @@
     case IMPORT_SERVER_FILE_SELECTED:
     case IMPORT_CA_FILE_SELECTED:
       ImportExportCleanup();
       break;
     default:
       NOTREACHED();
   }
 }
 
 void CertificateManagerHandler::View(const ListValue* args) {
-  net::X509Certificate* cert = CallbackArgsToCert(args);
+  net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert)
     return;
   ShowCertificateViewer(GetParentWindow(), cert);
 }
 
 void CertificateManagerHandler::GetCATrust(const ListValue* args) {
-  net::X509Certificate* cert = CallbackArgsToCert(args);
+  net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert) {
     web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
     return;
   }
 
   net::CertDatabase::TrustBits trust_bits =
       certificate_manager_model_->cert_db().GetCertTrust(cert, net::CA_CERT);
   base::FundamentalValue ssl_value(
       static_cast<bool>(trust_bits & net::CertDatabase::TRUSTED_SSL));
   base::FundamentalValue email_value(
       static_cast<bool>(trust_bits & net::CertDatabase::TRUSTED_EMAIL));
   base::FundamentalValue obj_sign_value(
       static_cast<bool>(trust_bits & net::CertDatabase::TRUSTED_OBJ_SIGN));
   web_ui()->CallJavascriptFunction(
       "CertificateEditCaTrustOverlay.populateTrust",
       ssl_value, email_value, obj_sign_value);
 }
 
 void CertificateManagerHandler::EditCATrust(const ListValue* args) {
-  net::X509Certificate* cert = CallbackArgsToCert(args);
+  net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   bool fail = !cert;
   bool trust_ssl = false;
   bool trust_email = false;
   bool trust_obj_sign = false;
   fail |= !CallbackArgsToBool(args, 1, &trust_ssl);
   fail |= !CallbackArgsToBool(args, 2, &trust_email);
   fail |= !CallbackArgsToBool(args, 3, &trust_obj_sign);
   if (fail) {
     LOG(ERROR) << "EditCATrust args fail";
     web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
@@ skipping 13 matching lines @@
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_SET_TRUST_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
   }
 }
 
 void CertificateManagerHandler::EditServer(const ListValue* args) {
   NOTIMPLEMENTED();
 }
 
 void CertificateManagerHandler::ExportPersonal(const ListValue* args) {
-  net::X509Certificate* cert = CallbackArgsToCert(args);
+  net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert)
     return;
 
   selected_cert_list_.push_back(cert);
 
   SelectFileDialog::FileTypeInfo file_type_info;
   file_type_info.extensions.resize(1);
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("p12"));
   file_type_info.extension_description_overrides.push_back(
       l10n_util::GetStringUTF16(IDS_CERT_MANAGER_PKCS12_FILES));
@@ skipping 12 matching lines @@
 
 void CertificateManagerHandler::ExportPersonalFileSelected(
     const FilePath& path) {
   file_path_ = path;
   web_ui()->CallJavascriptFunction(
       "CertificateManager.exportPersonalAskPassword");
 }
 
 void CertificateManagerHandler::ExportPersonalPasswordSelected(
     const ListValue* args) {
-  if (!args->GetString(0, &password_)){
+  if (!args->GetString(0, &password_)) {
     web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
     ImportExportCleanup();
     return;
   }
 
   // Currently, we don't support exporting more than one at a time.  If we do,
   // this would need to either change this to use UnlockSlotsIfNecessary or
   // change UnlockCertSlotIfNecessary to take a CertificateList.
   DCHECK_EQ(selected_cert_list_.size(), 1U);
 
@@ skipping 35 matching lines @@
   if (write_errno) {
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_PKCS12_EXPORT_ERROR_TITLE),
         l10n_util::GetStringFUTF8(IDS_CERT_MANAGER_WRITE_ERROR_FORMAT,
                                   UTF8ToUTF16(safe_strerror(write_errno))));
   }
 }
 
 void CertificateManagerHandler::StartImportPersonal(const ListValue* args) {
   SelectFileDialog::FileTypeInfo file_type_info;
-  if (!args->GetBoolean(0, &use_hardware_backed_)){
+  if (!args->GetBoolean(0, &use_hardware_backed_)) {
     // Unable to retrieve the hardware backed attribute from the args,
     // so bail.
     web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
     ImportExportCleanup();
     return;
   }
   file_type_info.extensions.resize(1);
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("p12"));
   file_type_info.extension_description_overrides.push_back(
       l10n_util::GetStringUTF16(IDS_CERT_MANAGER_PKCS12_FILES));
   file_type_info.include_all_files = true;
   select_file_dialog_ = SelectFileDialog::Create(this);
   select_file_dialog_->SelectFile(
       SelectFileDialog::SELECT_OPEN_FILE, string16(),
       FilePath(), &file_type_info, 1, FILE_PATH_LITERAL("p12"),
       web_ui()->GetWebContents(), GetParentWindow(),
       reinterpret_cast<void*>(IMPORT_PERSONAL_FILE_SELECTED));
 }
 
 void CertificateManagerHandler::ImportPersonalFileSelected(
     const FilePath& path) {
   file_path_ = path;
   web_ui()->CallJavascriptFunction(
       "CertificateManager.importPersonalAskPassword");
 }
 
 void CertificateManagerHandler::ImportPersonalPasswordSelected(
     const ListValue* args) {
-  if (!args->GetString(0, &password_)){
+  if (!args->GetString(0, &password_)) {
     web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
     ImportExportCleanup();
     return;
   }
   file_access_provider_->StartRead(
       file_path_,
       &consumer_,
       base::Bind(&CertificateManagerHandler::ImportPersonalFileRead,
                  base::Unretained(this)));
 }
@@ skipping 225 matching lines @@
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
   } else if (!not_imported.empty()) {
     ShowImportErrors(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CA_IMPORT_ERROR_TITLE),
         not_imported);
   }
   ImportExportCleanup();
 }
 
 void CertificateManagerHandler::Export(const ListValue* args) {
-  net::X509Certificate* cert = CallbackArgsToCert(args);
+  net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert)
     return;
   ShowCertExportDialog(web_ui()->GetWebContents(), GetParentWindow(),
                        cert->os_cert_handle());
 }
 
 void CertificateManagerHandler::Delete(const ListValue* args) {
-  net::X509Certificate* cert = CallbackArgsToCert(args);
+  net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert)
     return;
   bool result = certificate_manager_model_->Delete(cert);
   if (!result) {
     // TODO(mattm): better error messages?
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_DELETE_CERT_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
   }
 }
@@ skipping 27 matching lines @@
       DictionaryValue* dict = new DictionaryValue;
       dict->SetString(kKeyId, OrgNameToId(i->first));
       dict->SetString(kNameId, i->first);
 
       // Populate second level (certs).
       ListValue* subnodes = new ListValue;
       for (net::CertificateList::const_iterator org_cert_it = i->second.begin();
            org_cert_it != i->second.end(); ++org_cert_it) {
         DictionaryValue* cert_dict = new DictionaryValue;
         net::X509Certificate* cert = org_cert_it->get();
-        cert_dict->SetString(kKeyId, CertToId(*cert));
+        cert_dict->SetString(kKeyId, cert_id_map_->CertToId(cert));
         cert_dict->SetString(kNameId, certificate_manager_model_->GetColumnText(
             *cert, CertificateManagerModel::COL_SUBJECT_NAME));
         cert_dict->SetBoolean(
             kReadOnlyId,
             certificate_manager_model_->cert_db().IsReadOnly(cert));
         cert_dict->SetBoolean(
             kUntrustedId,
             certificate_manager_model_->cert_db().IsUntrusted(cert));
         // TODO(hshi): This should be determined by testing for PKCS #11
         // CKA_EXTRACTABLE attribute. We may need to use the NSS function
@@ skipping 76 matching lines @@
   web_ui()->CallJavascriptFunction("CertificateManager.onCheckTpmTokenReady",
                                    ready);
 }
 #endif
 
 gfx::NativeWindow CertificateManagerHandler::GetParentWindow() const {
   return web_ui()->GetWebContents()->GetView()->GetTopLevelNativeWindow();
 }
 
 }  // namespace options2