Use std::string references instead of copying contents.

talk/app/webrtc/webrtcsdp.cc

 /*
  * libjingle
  * Copyright 2011 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 698 matching lines @@
     current_preference = preference;
     current_family = family;
     *port = it->address().PortAsString();
     *ip = it->address().ipaddr().ToString();
   }
 }
 
 // Update |mline|'s default destination and append a c line after it.
 static void UpdateMediaDefaultDestination(
     const std::vector<Candidate>& candidates,
-    const std::string mline,
+    const std::string& mline,
     std::string* message) {
   std::string new_lines;
   AddLine(mline, &new_lines);
   // RFC 4566
   // m=<media> <port> <proto> <fmt> ...
   std::vector<std::string> fields;
   rtc::split(mline, kSdpDelimiterSpace, &fields);
   if (fields.size() < 3) {
     return;
   }
@@ skipping 71 matching lines @@
   std::string message;
 
   // Session Description.
   AddLine(kSessionVersion, &message);
   // Session Origin
   // RFC 4566
   // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
   // <unicast-address>
   std::ostringstream os;
   InitLine(kLineTypeOrigin, kSessionOriginUsername, &os);
-  const std::string session_id = jdesc.session_id().empty() ?
+  const std::string& session_id = jdesc.session_id().empty() ?
       kSessionOriginSessionId : jdesc.session_id();
-  const std::string session_version = jdesc.session_version().empty() ?
+  const std::string& session_version = jdesc.session_version().empty() ?
       kSessionOriginSessionVersion : jdesc.session_version();
   os << " " << session_id << " " << session_version << " "
      << kSessionOriginNettype << " " << kSessionOriginAddrtype << " "
      << kSessionOriginAddress;
   AddLine(os.str(), &message);
   AddLine(kSessionName, &message);
 
   // Time Description.
   AddLine(kTimeDescription, &message);
 
@@ skipping 170 matching lines @@
   // RFC 5245
   // a=candidate:<foundation> <component-id> <transport> <priority>
   // <connection-address> <port> typ <candidate-types>
   // [raddr <connection-address>] [rport <port>]
   // *(SP extension-att-name SP extension-att-value)
   const size_t expected_min_fields = 8;
   if (fields.size() < expected_min_fields ||
       (fields[6] != kAttributeCandidateTyp)) {
     return ParseFailedExpectMinFieldNum(first_line, expected_min_fields, error);
   }
-  std::string foundation = fields[0];
+  const std::string& foundation = fields[0];
 
   int component_id = 0;
   if (!GetValueFromString(first_line, fields[1], &component_id, error)) {
     return false;
   }
-  const std::string transport = fields[2];
+  const std::string& transport = fields[2];
   uint32 priority = 0;
   if (!GetValueFromString(first_line, fields[3], &priority, error)) {
     return false;
   }
-  const std::string connection_address = fields[4];
+  const std::string& connection_address = fields[4];
   int port = 0;
   if (!GetValueFromString(first_line, fields[5], &port, error)) {
     return false;
   }
   SocketAddress address(connection_address, port);
 
   cricket::ProtocolType protocol;
   if (!StringToProto(transport.c_str(), &protocol)) {
     return ParseFailed(first_line, "Unsupported transport type.", error);
   }
 
   std::string candidate_type;
-  const std::string type = fields[7];
+  const std::string& type = fields[7];
   if (type == kCandidateHost) {
     candidate_type = cricket::LOCAL_PORT_TYPE;
   } else if (type == kCandidateSrflx) {
     candidate_type = cricket::STUN_PORT_TYPE;
   } else if (type == kCandidateRelay) {
     candidate_type = cricket::RELAY_PORT_TYPE;
   } else {
     return ParseFailed(first_line, "Unsupported candidate type.", error);
   }
 
@@ skipping 214 matching lines @@
   // to 0.
   if (fmt.empty()) {
     fmt = " 0";
   }
 
   // The port number in the m line will be updated later when associate with
   // the candidates.
   // RFC 3264
   // To reject an offered stream, the port number in the corresponding stream in
   // the answer MUST be set to zero.
-  const std::string port = content_info->rejected ?
+  const std::string& port = content_info->rejected ?
       kMediaPortRejected : kDummyPort;
 
   rtc::SSLFingerprint* fp = (transport_info) ?
       transport_info->description.identity_fingerprint.get() : NULL;
 
   // Add the m and c lines.
   InitLine(kLineTypeMedia, type, &os);
   os << " " << port << " " << media_desc->protocol() << fmt;
   std::string mline = os.str();
   UpdateMediaDefaultDestination(candidates, mline, message);
@@ skipping 1564 matching lines @@
     return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
   }
   std::string tag_value;
   if (!GetValue(fields[0], kAttributeCrypto, &tag_value, error)) {
     return false;
   }
   int tag = 0;
   if (!GetValueFromString(line, tag_value, &tag, error)) {
     return false;
   }
-  const std::string crypto_suite = fields[1];
-  const std::string key_params = fields[2];
+  const std::string& crypto_suite = fields[1];
+  const std::string& key_params = fields[2];
   std::string session_params;
   if (fields.size() > 3) {
     session_params = fields[3];
   }
   media_desc->AddCrypto(CryptoParams(tag, crypto_suite, key_params,
                                      session_params));
   return true;
 }
 
 // Updates or creates a new codec entry in the audio description with according
@@ skipping 59 matching lines @@
   // Set the preference order depending on the order of the pl type in the
   // <fmt> of the m-line.
   const int preference = codec_preference.end() -
       std::find(codec_preference.begin(), codec_preference.end(),
                 payload_type);
   if (preference == 0) {
     LOG(LS_WARNING) << "Ignore rtpmap line that did not appear in the "
                     << "<fmt> of the m-line: " << line;
     return true;
   }
-  const std::string encoder = fields[1];
+  const std::string& encoder = fields[1];
   std::vector<std::string> codec_params;
   rtc::split(encoder, '/', &codec_params);
   // <encoding name>/<clock rate>[/<encodingparameters>]
   // 2 mandatory fields
   if (codec_params.size() < 2 || codec_params.size() > 3) {
     return ParseFailed(line,
                        "Expected format \"<encoding name>/<clock rate>"
                        "[/<encodingparameters>]\".",
                        error);
   }
-  const std::string encoding_name = codec_params[0];
+  const std::string& encoding_name = codec_params[0];
   int clock_rate = 0;
   if (!GetValueFromString(line, codec_params[1], &clock_rate, error)) {
     return false;
   }
   if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     VideoContentDescription* video_desc =
         static_cast<VideoContentDescription*>(media_desc);
     // TODO: We will send resolution in SDP. For now use
     // JsepSessionDescription::kMaxVideoCodecWidth and kMaxVideoCodecHeight.
     UpdateCodec(payload_type, encoding_name,
@@ skipping 147 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc