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::Type type;
+  const char* name;
+};
+
+static const MessageLoopTypeNamePair kMessageLoopTypeToNameMapping[] = {
+  { MessageLoopFactory::kAudioDecoder, "AudioDecoderThread" },
+  { MessageLoopFactory::kVideoDecoder, "VideoDecoderThread" },
+  { MessageLoopFactory::kPipeline, "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();
+scoped_refptr<base::MessageLoopProxy> MessageLoopFactory::GetMessageLoop(
+    Type type) {
+  return GetThread(type)->message_loop_proxy();
 }
 
-scoped_refptr<base::MessageLoopProxy>
-MessageLoopFactory::GetMessageLoopProxy(const std::string& name) {
-  return GetThread(name)->message_loop_proxy();
-}
-
-base::Thread* MessageLoopFactory::GetThread(const std::string& name) {
-  DCHECK(!name.empty());
-
+base::Thread* MessageLoopFactory::GetThread(Type 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(kMessageLoopTypeToNameMapping); ++i) {
+    if (kMessageLoopTypeToNameMapping[i].type == type)
+      name = kMessageLoopTypeToNameMapping[i].name;
+  }
+  DCHECK(!name.empty());
+
   base::Thread* thread = new base::Thread(name.c_str());

[Ami GONE FROM CHROMIUM, 2012/08/10 04:38:06]

I think you're working too hard on this :)
l.16-21 and l45-57 can be replaced with:

const char* name = NULL;
switch (type) {
 case kAudioDecoder: 
  name = "AudioDecoderThread"; 
  break;
 case kVideoDecoder: 
  name = "VideoDecoderThread"; 
  break;
 case kPipeline:
  name = "PipelineThread"; 
  break;
}
base::Thread* thread = new base::Thread(name);
CHECK(thread->Start()) << "Failed to start thread: " << name;
threads_.push_back(std::make_pair(type, thread));
return thread;


(the benefits are:
1) compiler checks all the types are handled
2) the literal names are present exactly where they are used
3) it's simpler/shorter)

[scherkus (not reviewing), 2012/08/10 17:00:09]

+1

[xhwang, 2012/08/10 19:33:33]

Done.

   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