switch to DVLOG from VLOG, and move struct definition to cc file

content/renderer/media/media_stream_dispatcher.cc

 // Copyright (c) 2011 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/renderer/media/media_stream_dispatcher.h"
 
 #include "base/logging.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
 #include "content/renderer/render_view_impl.h"
 
+struct MediaStreamDispatcher::Request {
+  Request(MediaStreamDispatcherEventHandler* handler,
+          int request_id,
+          int ipc_request)
+      : handler(handler),
+        request_id(request_id),
+        ipc_request(ipc_request) {
+  }
+  MediaStreamDispatcherEventHandler* handler;
+  int request_id;
+  int ipc_request;
+};
+
+struct MediaStreamDispatcher::Stream {
+  Stream() : handler(NULL) {}
+  ~Stream() {}
+  MediaStreamDispatcherEventHandler* handler;
+  media_stream::StreamDeviceInfoArray audio_array;
+  media_stream::StreamDeviceInfoArray video_array;
+};
+
 MediaStreamDispatcherEventHandler::~MediaStreamDispatcherEventHandler() {}
 
 MediaStreamDispatcher::MediaStreamDispatcher(RenderViewImpl* render_view)
     : content::RenderViewObserver(render_view),
       next_ipc_id_(0) {
 }
 
 MediaStreamDispatcher::~MediaStreamDispatcher() {}
 
 void MediaStreamDispatcher::GenerateStream(
     int request_id,
     MediaStreamDispatcherEventHandler* event_handler,
     media_stream::StreamOptions components,
     const std::string& security_origin) {
-  VLOG(1) << "MediaStreamDispatcher::GenerateStream(" << request_id << ")";
+  DVLOG(1) << "MediaStreamDispatcher::GenerateStream(" << request_id << ")";
 
   requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
   Send(new MediaStreamHostMsg_GenerateStream(routing_id(),
                                              next_ipc_id_++,
                                              components,
                                              security_origin));
 }
 
 void MediaStreamDispatcher::StopStream(const std::string& label) {
-  VLOG(1) << "MediaStreamDispatcher::StopStream"
-          << ", {label = " << label << "}";
+  DVLOG(1) << "MediaStreamDispatcher::StopStream"
+           << ", {label = " << label << "}";
 
   LabelStreamMap::iterator it = label_stream_map_.find(label);
   if (it == label_stream_map_.end())
     return;
 
   Send(new MediaStreamHostMsg_StopGeneratedStream(routing_id(), label));
   label_stream_map_.erase(it);
 }
 
 bool MediaStreamDispatcher::OnMessageReceived(const IPC::Message& message) {
@@ skipping 22 matching lines @@
        it != requests_.end(); ++it) {
     Request& request = *it;
     if (request.ipc_request == request_id) {
       Stream new_stream;
       new_stream.handler = request.handler;
       new_stream.audio_array = audio_array;
       new_stream.video_array = video_array;
       label_stream_map_[label] = new_stream;
       request.handler->OnStreamGenerated(request.request_id, label,
                                          audio_array, video_array);
-      VLOG(1) << "MediaStreamDispatcher::OnStreamGenerated("
-              << request.request_id << ", " << label << ")";
+      DVLOG(1) << "MediaStreamDispatcher::OnStreamGenerated("
+               << request.request_id << ", " << label << ")";
       requests_.erase(it);
       break;
     }
   }
 }
 
 void MediaStreamDispatcher::OnStreamGenerationFailed(int request_id) {
   for (RequestList::iterator it = requests_.begin();
        it != requests_.end(); ++it) {
     Request& request = *it;
     if (request.ipc_request == request_id) {
       request.handler->OnStreamGenerationFailed(request.request_id);
-      VLOG(1) << "MediaStreamDispatcher::OnStreamGenerationFailed("
-              << request.request_id << ")\n";
+      DVLOG(1) << "MediaStreamDispatcher::OnStreamGenerationFailed("
+               << request.request_id << ")\n";
       requests_.erase(it);
       break;
     }
   }
 }
 
 void MediaStreamDispatcher::OnVideoDeviceFailed(const std::string& label,
                                                 int index) {
   LabelStreamMap::iterator it = label_stream_map_.find(label);
   if (it == label_stream_map_.end())
@@ skipping 37 matching lines @@
 
 int MediaStreamDispatcher::video_session_id(const std::string& label,
                                             int index) {
   LabelStreamMap::iterator it = label_stream_map_.find(label);
   if (it == label_stream_map_.end())
     return media_stream::StreamDeviceInfo::kNoId;
 
   DCHECK_GT(it->second.video_array.size(), static_cast<size_t>(index));
   return it->second.video_array[index].session_id;
 }
-
-MediaStreamDispatcher::Stream::Stream()
-    : handler(NULL) {}
-
-MediaStreamDispatcher::Stream::~Stream() {}
-