[UMA] Use proper C++ objects to serialize tracked_objects across process boundaries.

base/location.h

 // 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.
 
 #ifndef BASE_LOCATION_H_
 #define BASE_LOCATION_H_
 
 #include <string>
 
 #include "base/base_export.h"
 
-namespace base {
-class DictionaryValue;
-}
-
 namespace tracked_objects {
 
 // Location provides basic info where of an object was constructed, or was
 // significantly brought to life.
 class BASE_EXPORT Location {
  public:
   // Constructor should be called with a long-lived char*, such as __FILE__.
   // It assumes the provided value will persist as a global constant, and it
   // will not make a copy of it.
   Location(const char* function_name,
@@ skipping 28 matching lines @@
   // Translate the some of the state in this instance into a human readable
   // string with HTML characters in the function names escaped, and append that
   // string to |output|.  Inclusion of the file_name_ and function_name_ are
   // optional, and controlled by the boolean arguments.
   void Write(bool display_filename, bool display_function_name,
              std::string* output) const;
 
   // Write function_name_ in HTML with '<' and '>' properly encoded.
   void WriteFunctionName(std::string* output) const;
 
-  // Construct a Value* representation.  The caller assumes ownership of the
-  // memory in the returned instance.
-  base::DictionaryValue* ToValue() const;
-
  private:
   const char* function_name_;
   const char* file_name_;
   int line_number_;
   const void* program_counter_;
 };
 
+// Serialized representation of the Location class that can safely be passed
+// across process boundaries.
+struct BASE_EXPORT SerializedLocation {

[jar (doing other things), 2012/03/21 18:19:55]

IMO: It is much better to use classes, and accessors, than to use a struct. The
privacy of the members makes it easy to read locally, without fears that other
folks will change the interior values.

[Ilya Sherman, 2012/03/21 19:23:02]

Hmm.  If these were to be classes, they would need both setters and getters, as
(to the best of my knowledge) the IPC code requires some way to initialize data
other than through the constructor.  So, making these be proper classes, rather
than structs, would not add any safety, but it would add a bunch of extra
boiler-plate code...

+  // The default constructor is exposed to support the IPC serialization macros.
+  SerializedLocation();
+  explicit SerializedLocation(const tracked_objects::Location& location);
+  ~SerializedLocation();
+
+  std::string file_name;
+  std::string function_name;
+  int line_number;
+};
+
 BASE_EXPORT const void* GetProgramCounter();
 
 // Define a macro to record the current source location.
 #define FROM_HERE FROM_HERE_WITH_EXPLICIT_FUNCTION(__FUNCTION__)
 
 #define FROM_HERE_WITH_EXPLICIT_FUNCTION(function_name)                        \
     ::tracked_objects::Location(function_name,                                 \
                                 __FILE__,                                      \
                                 __LINE__,                                      \
                                 ::tracked_objects::GetProgramCounter())
 
 }  // namespace tracked_objects
 
 #endif  // BASE_LOCATION_H_