Make dbus file descriptor check dynamic

dbus/message.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 "dbus/message.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "dbus/object_path.h"
 #include "third_party/protobuf/src/google/protobuf/message_lite.h"
 
 namespace {
 
 // Appends the header name and the value to |output|, if the value is
 // not empty.
-static void AppendStringHeader(const std::string& header_name,
-                               const std::string& header_value,
-                               std::string* output) {
+void AppendStringHeader(const std::string& header_name,
+                        const std::string& header_value,
+                        std::string* output) {
   if (!header_value.empty()) {
     *output += header_name + ": " + header_value + "\n";
   }
 }
 
 // Appends the header name and the value to |output|, if the value is
 // nonzero.
-static void AppendUint32Header(const std::string& header_name,
-                               uint32 header_value,
-                               std::string* output) {
+void AppendUint32Header(const std::string& header_name,
+                        uint32 header_value,
+                        std::string* output) {
   if (header_value != 0) {
     *output += (header_name + ": " + base::StringPrintf("%u", header_value) +
                 "\n");
   }
 }
 
+bool IsDBusTypeUnixFdSupported() {

[satorux1, 2012/07/24 21:49:08]

It's not obvious why we should check this run time. maybe add something like:

// Returns true if Unix FD passing is supported in libdbus.
// The check is done runtime rather than compile time as the libdbus
// version used at runtime may be different from the one used at compile time.

+  int major, minor, micro;

[satorux1, 2012/07/24 21:49:08]

nit: initialize them with 0 just in case.

+  dbus_get_version(&major, &minor, &micro);
+  return major >= 1 && minor >= 4;
+}
+
 }  // namespace
 
 namespace dbus {
 
 Message::Message()
     : raw_message_(NULL) {
 }
 
 Message::~Message() {
   if (raw_message_)
@@ skipping 154 matching lines @@
       }
       case VARIANT: {
         MessageReader sub_reader(this);
         if (!reader->PopVariant(&sub_reader))
           return kBrokenMessage;
         output += indent + "variant ";
         output += ToStringInternal(indent + "  ", &sub_reader);
         break;
       }
       case UNIX_FD: {
-        CHECK(kDBusTypeUnixFdIsSupported);
+        CHECK(IsDBusTypeUnixFdSupported());
 
         FileDescriptor file_descriptor;
         if (!reader->PopFileDescriptor(&file_descriptor))
           return kBrokenMessage;
         output += indent + "fd#" +
                   base::StringPrintf("%d", file_descriptor.value()) + "\n";
         break;
       }
       default:
         LOG(FATAL) << "Unknown type: " << type;
@@ skipping 458 matching lines @@
 
 void MessageWriter::AppendVariantOfBasic(int dbus_type, const void* value) {
   const std::string signature = base::StringPrintf("%c", dbus_type);
   MessageWriter variant_writer(message_);
   OpenVariant(signature, &variant_writer);
   variant_writer.AppendBasic(dbus_type, value);
   CloseContainer(&variant_writer);
 }
 
 void MessageWriter::AppendFileDescriptor(const FileDescriptor& value) {
-  CHECK(kDBusTypeUnixFdIsSupported);
+  CHECK(IsDBusTypeUnixFdSupported());
 
   if (!value.is_valid()) {
     // NB: sending a directory potentially enables sandbox escape
     LOG(FATAL) << "Attempt to pass invalid file descriptor";
   }
   int fd = value.value();
   AppendBasic(DBUS_TYPE_UNIX_FD, &fd);
 }
 
 //
@@ skipping 249 matching lines @@
 }
 
 bool MessageReader::PopVariantOfBasic(int dbus_type, void* value) {
   dbus::MessageReader variant_reader(message_);
   if (!PopVariant(&variant_reader))
     return false;
   return variant_reader.PopBasic(dbus_type, value);
 }
 
 bool MessageReader::PopFileDescriptor(FileDescriptor* value) {
-  CHECK(kDBusTypeUnixFdIsSupported);
+  CHECK(IsDBusTypeUnixFdSupported());
 
   int fd = -1;
   const bool success = PopBasic(DBUS_TYPE_UNIX_FD, &fd);
   if (!success)
     return false;
 
   value->PutValue(fd);
   // NB: the caller must check validity before using the value
   return true;
 }
 
 }  // namespace dbus