Use enum instead of string in MessageLoopFactory::GetMessageLoop*

media/base/message_loop_factory.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 "media/base/message_loop_factory.h"
 
 #include "base/threading/thread.h"
 
 namespace media {
 
+struct MessageLoopTypeNamePair {
+  MessageLoopFactory::MessageLoopType type;
+  const char* name;
+};
+
+static const MessageLoopTypeNamePair message_loop_type_to_name_mapping[] = {

[scherkus (not reviewing), 2012/08/09 17:13:24]

this should be kMessageLoopXxx

[xhwang, 2012/08/10 01:04:28]

Done.

+  { MessageLoopFactory::AUDIO_DECODER, "AudioDecoderThread" },
+  { MessageLoopFactory::VIDEO_DECODER, "VideoDecoderThread" },
+  { MessageLoopFactory::PIPELINE, "PipelineThread" }
+};
+
 MessageLoopFactory::MessageLoopFactory() {}
 
 MessageLoopFactory::~MessageLoopFactory() {
   for (ThreadList::reverse_iterator it = threads_.rbegin();
        it != threads_.rend(); ++it) {
     base::Thread* thread = it->second;
     thread->Stop();
     delete thread;
   }
   threads_.clear();
 }
 
-MessageLoop* MessageLoopFactory::GetMessageLoop(const std::string& name) {
-  return GetThread(name)->message_loop();
+MessageLoop* MessageLoopFactory::GetMessageLoop(MessageLoopType type) {
+  return GetThread(type)->message_loop();
 }
 
 scoped_refptr<base::MessageLoopProxy>
-MessageLoopFactory::GetMessageLoopProxy(const std::string& name) {
-  return GetThread(name)->message_loop_proxy();
+MessageLoopFactory::GetMessageLoopProxy(MessageLoopType type) {
+  return GetThread(type)->message_loop_proxy();
 }
 
-base::Thread* MessageLoopFactory::GetThread(const std::string& name) {
-  DCHECK(!name.empty());
-
+base::Thread* MessageLoopFactory::GetThread(MessageLoopType type) {
   base::AutoLock auto_lock(lock_);
   for (ThreadList::iterator it = threads_.begin(); it != threads_.end(); ++it) {
-    if (it->first == name)
+    if (it->first == type)
       return it->second;
   }
 
+  std::string name;
+  for (size_t i = 0; i < arraysize(message_loop_type_to_name_mapping); ++i) {
+    if (message_loop_type_to_name_mapping[i].type == type)
+      name = message_loop_type_to_name_mapping[i].name;
+  }
+  DCHECK(!name.empty());
+
   base::Thread* thread = new base::Thread(name.c_str());
   CHECK(thread->Start()) << "Failed to start thread: " << name;
-  threads_.push_back(std::make_pair(name, thread));
+  threads_.push_back(std::make_pair(type, thread));
   return thread;
 }
 
 }  // namespace media