Improve map insertions

handler/mac/crash_report_upload_thread.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "handler/mac/crash_report_upload_thread.h"
 
 #include <errno.h>
 #include <time.h>
 
 #include <map>
 #include <vector>
-#include <utility>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "client/settings.h"
 #include "snapshot/minidump/process_snapshot_minidump.h"
 #include "snapshot/module_snapshot.h"
 #include "util/file/file_reader.h"
 #include "util/misc/uuid.h"
 #include "util/net/http_body.h"
 #include "util/net/http_multipart_builder.h"
 #include "util/net/http_transport.h"
+#include "util/stdlib/map_insert.h"
 
 namespace crashpad {
 
 namespace {
 
 void InsertOrReplaceMapEntry(std::map<std::string, std::string>* map,
                              const std::string& key,
                              const std::string& value) {
-  auto it = map->find(key);
-  if (it != map->end()) {
+  std::string old_value;
+  if (!MapInsertOrReplace(map, key, value, &old_value)) {
     LOG(WARNING) << "duplicate key " << key << ", discarding value "
-                 << it->second;
-    it->second = value;
-  } else {
-    map->insert(std::make_pair(key, value));
+                 << old_value;
   }
 }
 
 // Given a minidump file readable by |minidump_file_reader|, returns a map of
 // key-value pairs to use as HTTP form parameters for upload to a Breakpad
 // server. The map is built by combining the process simple annotations map with
 // each module’s simple annotations map. In the case of duplicate keys, the map
 // will retain the first value found for any key, and will log a warning about
 // discarded values. Each module’s annotations vector is also examined and built
 // into a single string value, with distinct elements separated by newlines, and
 // stored at the key named “list_annotations”, which supersedes any other key
 // found by that name. The client ID stored in the minidump is converted to
 // a string and stored at the key named “guid”, which supersedes any other key
 // found by that name.
 //
 // In the event of an error reading the minidump file, a message will be logged.
 std::map<std::string, std::string> BreakpadHTTPFormParametersFromMinidump(
     FileReader* minidump_file_reader) {
   ProcessSnapshotMinidump minidump_process_snapshot;
   if (!minidump_process_snapshot.Initialize(minidump_file_reader)) {
     return std::map<std::string, std::string>();
   }
 
   std::map<std::string, std::string> parameters =
       minidump_process_snapshot.AnnotationsSimpleMap();
 
   std::string list_annotations;
   for (const ModuleSnapshot* module : minidump_process_snapshot.Modules()) {
     for (const auto& kv : module->AnnotationsSimpleMap()) {
-      if (parameters.find(kv.first) != parameters.end()) {
+      if (!parameters.insert(kv).second) {
         LOG(WARNING) << "duplicate key " << kv.first << ", discarding value "
                      << kv.second;
-      } else {
-        parameters.insert(kv);
       }
     }
 
     for (std::string annotation : module->AnnotationsVector()) {
       list_annotations.append(annotation);
       list_annotations.append("\n");
     }
   }
 
   if (!list_annotations.empty()) {
@@ skipping 269 matching lines @@
 }
 
 // static
 void* CrashReportUploadThread::RunThreadMain(void* arg) {
   CrashReportUploadThread* self = static_cast<CrashReportUploadThread*>(arg);
   self->ThreadMain();
   return nullptr;
 }
 
 }  // namespace crashpad