Do not call SendMessageToNativeLog on Android in AudioInputSyncWriter

content/browser/renderer_host/media/audio_input_sync_writer.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 "content/browser/renderer_host/media/audio_input_sync_writer.h"
 
 #include <algorithm>
 
 #include "base/memory/shared_memory.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 
-static const uint32 kLogDelayThreadholdMs = 500;
-
 namespace content {
 
 AudioInputSyncWriter::AudioInputSyncWriter(
     base::SharedMemory* shared_memory,
     int shared_memory_segment_count)
     : shared_memory_(shared_memory),
       shared_memory_segment_count_(shared_memory_segment_count),
       current_segment_id_(0),
       creation_time_(base::Time::Now()) {
   DCHECK_GT(shared_memory_segment_count, 0);
   DCHECK_EQ(shared_memory->requested_size() % shared_memory_segment_count, 0u);
   shared_memory_segment_size_ =
       shared_memory->requested_size() / shared_memory_segment_count;
 }
 
 AudioInputSyncWriter::~AudioInputSyncWriter() {}
 
 // TODO(henrika): Combine into one method (including Write).
 void AudioInputSyncWriter::UpdateRecordedBytes(uint32 bytes) {
   socket_->Send(&bytes, sizeof(bytes));
 }
 
 uint32 AudioInputSyncWriter::Write(const void* data,
                                    uint32 size,
                                    double volume,
                                    bool key_pressed) {
+#if !defined(OS_ANDROID)
+  static const uint32 kLogDelayThreadholdMs = 500;

[Ami GONE FROM CHROMIUM, 2014/05/21 18:38:38]

FWIW now that this is a function-static instead of a file-static you could
static const base::TimeDelta kLogDelayThreshold =
base::TimeDelta::FromMilliseconds(500);

and avoid the need for InMilliseconds at l.49.

+
   std::ostringstream oss;
   if (last_write_time_.is_null()) {
     // This is the first time Write is called.
     base::TimeDelta interval = base::Time::Now() - creation_time_;
     oss << "Audio input data received for the first time: delay = "
         << interval.InMilliseconds() << "ms.";
   } else {
     base::TimeDelta interval = base::Time::Now() - last_write_time_;
     if (interval.InMilliseconds() > kLogDelayThreadholdMs) {
       oss << "Audio input data delay unexpectedly long: delay = "
          << interval.InMilliseconds() << "ms.";
     }
   }
   if (!oss.str().empty())
     MediaStreamManager::SendMessageToNativeLog(oss.str());
 
   last_write_time_ = base::Time::Now();
+#endif
 
   uint8* ptr = static_cast<uint8*>(shared_memory_->memory());
   ptr += current_segment_id_ * shared_memory_segment_size_;
   media::AudioInputBuffer* buffer =
       reinterpret_cast<media::AudioInputBuffer*>(ptr);
   buffer->params.volume = volume;
   buffer->params.size = size;
   buffer->params.key_pressed = key_pressed;
   memcpy(buffer->audio, data, size);
 
@@ skipping 31 matching lines @@
     base::ProcessHandle process_handle,
     base::FileDescriptor* foreign_handle) {
   foreign_handle->fd = foreign_socket_->handle();
   foreign_handle->auto_close = false;
   return (foreign_handle->fd != -1);
 }
 
 #endif
 
 }  // namespace content