Refactor the VideoCaptureDevice::Name struct.

media/video/capture/win/video_capture_device_win.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/video/capture/win/video_capture_device_win.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_variant.h"
 #include "media/video/capture/win/video_capture_device_mf_win.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
+namespace media {
 namespace {
 
 // Finds and creates a DirectShow Video Capture filter matching the device_name.
-HRESULT GetDeviceFilter(const media::VideoCaptureDevice::Name& device_name,
+HRESULT GetDeviceFilter(const VideoCaptureDevice::Name& device_name,
                         IBaseFilter** filter) {
   DCHECK(filter);
 
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
   if (FAILED(hr))
     return hr;
 
   ScopedComPtr<IEnumMoniker> enum_moniker;
@@ skipping 19 matching lines @@
     static const wchar_t* kPropertyNames[] = {
       L"DevicePath", L"Description", L"FriendlyName"
     };
     ScopedVariant name;
     for (size_t i = 0;
          i < arraysize(kPropertyNames) && name.type() != VT_BSTR; ++i) {
       prop_bag->Read(kPropertyNames[i], name.Receive(), 0);
     }
     if (name.type() == VT_BSTR) {
       std::string device_path(base::SysWideToUTF8(V_BSTR(&name)));
-      if (device_path.compare(device_name.unique_id) == 0) {
+      if (device_path.compare(device_name.id()) == 0) {
         // We have found the requested device
         hr = moniker->BindToObject(0, 0, IID_IBaseFilter,
                                    capture_filter.ReceiveVoid());
         DVPLOG_IF(2, FAILED(hr)) << "Failed to bind camera filter.";
         break;
       }
     }
     moniker.Release();
   }
 
@@ skipping 66 matching lines @@
 // http://msdn.microsoft.com/en-us/library/dd375432(VS.85).aspx
 void DeleteMediaType(AM_MEDIA_TYPE* mt) {
   if (mt != NULL) {
     FreeMediaType(mt);
     CoTaskMemFree(mt);
   }
 }
 
 }  // namespace
 
-namespace media {
-
 // static
 void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
   if (VideoCaptureDeviceMFWin::PlatformSupported()) {
     VideoCaptureDeviceMFWin::GetDeviceNames(device_names);
   } else {
     VideoCaptureDeviceWin::GetDeviceNames(device_names);
   }
 }
 
 // static
@@ skipping 35 matching lines @@
   device_names->clear();
 
   // Name of a fake DirectShow filter that exist on computers with
   // GTalk installed.
   static const char kGoogleCameraAdapter[] = "google camera adapter";
 
   // Enumerate all video capture devices.
   ScopedComPtr<IMoniker> moniker;
   int index = 0;
   while (enum_moniker->Next(1, moniker.Receive(), NULL) == S_OK) {
-    Name device;
     ScopedComPtr<IPropertyBag> prop_bag;
     hr = moniker->BindToStorage(0, 0, IID_IPropertyBag, prop_bag.ReceiveVoid());
     if (FAILED(hr)) {
       moniker.Release();
       continue;
     }
 
     // Find the description or friendly name.
     ScopedVariant name;
     hr = prop_bag->Read(L"Description", name.Receive(), 0);
     if (FAILED(hr))
       hr = prop_bag->Read(L"FriendlyName", name.Receive(), 0);
 
     if (SUCCEEDED(hr) && name.type() == VT_BSTR) {
       // Ignore all VFW drivers and the special Google Camera Adapter.
       // Google Camera Adapter is not a real DirectShow camera device.
       // VFW is very old Video for Windows drivers that can not be used.
       const wchar_t* str_ptr = V_BSTR(&name);
       const int name_length = arraysize(kGoogleCameraAdapter) - 1;
 
       if ((wcsstr(str_ptr, L"(VFW)") == NULL) &&
           lstrlenW(str_ptr) < name_length ||
           (!(LowerCaseEqualsASCII(str_ptr, str_ptr + name_length,
                                   kGoogleCameraAdapter)))) {
-        device.device_name = base::SysWideToUTF8(str_ptr);
+        std::string id;
+        std::string device_name(base::SysWideToUTF8(str_ptr));
         name.Reset();
         hr = prop_bag->Read(L"DevicePath", name.Receive(), 0);
-        if (FAILED(hr)) {
-          device.unique_id = device.device_name;
-        } else if (name.type() == VT_BSTR) {
-          device.unique_id = base::SysWideToUTF8(V_BSTR(&name));
+        if (FAILED(hr) || name.type() != VT_BSTR) {
+          id = device_name;
+        } else {
+          DCHECK_EQ(name.type(), VT_BSTR);
+          id = base::SysWideToUTF8(V_BSTR(&name));
         }
 
-        device_names->push_back(device);
+        device_names->push_back(Name(device_name, id));
       }
     }
     moniker.Release();
   }
 }
 
 VideoCaptureDeviceWin::VideoCaptureDeviceWin(const Name& device_name)
     : device_name_(device_name),
       state_(kIdle),
       observer_(NULL) {
@@ skipping 341 matching lines @@
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const char* reason) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << reason;
   state_ = kError;
   observer_->OnError();
 }
 
 }  // namespace media