Remove redundant c_str() calls.

base/trace_event/trace_config.cc

 // Copyright (c) 2015 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 "base/trace_event/trace_config.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 303 matching lines @@
   bool had_enabled_by_default = false;
   DCHECK(category_group_name);
   std::string category_group_name_str = category_group_name;
   StringTokenizer category_group_tokens(category_group_name_str, ",");
   while (category_group_tokens.GetNext()) {
     std::string category_group_token = category_group_tokens.token();
     // Don't allow empty tokens, nor tokens with leading or trailing space.
     DCHECK(!TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
                category_group_token))
         << "Disallowed category string";
-    if (IsCategoryEnabled(category_group_token.c_str()))
+    if (IsCategoryEnabled(category_group_token))
       return true;
 
     if (!MatchPattern(category_group_token, TRACE_DISABLED_BY_DEFAULT("*")))
       had_enabled_by_default = true;
   }
   // Do a second pass to check for explicitly disabled categories
   // (those explicitly enabled have priority due to first pass).
   category_group_tokens.Reset();
   bool category_group_disabled = false;
   while (category_group_tokens.GetNext()) {
@@ skipping 513 matching lines @@
   int token_cnt = 0;
   for (const std::string& category : delays) {
     if (token_cnt > 0 || prepend_comma)
       StringAppendF(out, ",");
     StringAppendF(out, "%s%s)", kSyntheticDelayCategoryFilterPrefix,
                   category.c_str());
     ++token_cnt;
   }
 }
 
-bool TraceConfig::IsCategoryEnabled(const char* category_name) const {
+bool TraceConfig::IsCategoryEnabled(StringPiece category_name) const {

[Andrey Kraynov, 2017/01/09 21:50:45]

Later |category_name| will be used as an argument for MatchPattern() function
https://cs.chromium.org/chromium/src/base/trace_event/trace_config.cc?q=IsCat...

It has following signature - |bool MatchPattern(const StringPiece&, const
StringPiece&)|
https://cs.chromium.org/chromium/src/base/strings/pattern.h?q=MatchPattern&sq...

[Primiano Tucci (use gerrit), 2017/01/09 23:52:37]

Please don't change this signature. This is used by very hot code in the tracing
codebase which passes always const char ptr. Of you do this you will cause an
implicit temporary string piece to be constructed. 

[Andrey Kraynov, 2017/01/10 06:24:53]

My point was that in case of the old signature of IsCategoryEnabled(), temporary
StringPiece objects will be constructed every time MatchPattern is called from
IsCategoryEnabled() function. MatchPattern() isn't an inline function so when
passing a |const char*| to it, StringPiece should be created.

Am I missing something?

[Primiano Tucci (use gerrit), 2017/01/10 10:48:43]

ahh sorry you are right, it would actually happen below. please ignore my
comment.

   // Check the disabled- filters and the disabled-* wildcard first so that a
   // "*" filter does not include the disabled.
   for (const std::string& category : disabled_categories_) {
     if (MatchPattern(category_name, category))
       return true;
   }
 
   if (MatchPattern(category_name, TRACE_DISABLED_BY_DEFAULT("*")))
     return false;
 
   for (const std::string& category : included_categories_) {
     if (MatchPattern(category_name, category))
       return true;
   }
 
   return false;
 }
 
 bool TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
     StringPiece str) {
   return str.empty() || str.front() == ' ' || str.back() == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base