Extract VideoCaptureDeviceFactory out of VideoCaptureDevice and use for File and FakeVCD.

media/video/capture/file_video_capture_device.cc

 // Copyright 2013 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/file_video_capture_device.h"
 
 #include <string>
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
-#include "base/strings/sys_string_conversions.h"
-#include "media/base/media_switches.h"
-
 
 namespace media {
-static const char kFileVideoCaptureDeviceName[] =
-    "/dev/placeholder-for-file-backed-fake-capture-device";
-
 static const int kY4MHeaderMaxSize = 200;
 static const char kY4MSimpleFrameDelimiter[] = "FRAME";
 static const int kY4MSimpleFrameDelimiterSize = 6;
 
 int ParseY4MInt(const base::StringPiece& token) {
   int temp_int;
   CHECK(base::StringToInt(token, &temp_int)) << token;
   return temp_int;
 }
 
@@ skipping 71 matching lines @@
     index = blank_position + 1;
   }
   // Last video format semantic correctness check before sending it back.
   CHECK(video_format->IsValid());
 }
 
 // Reads and parses the header of a Y4M |file|, returning the collected pixel
 // format in |video_format|. Returns the index of the first byte of the first
 // video frame.
 // Restrictions: Only trivial per-frame headers are supported.
-int64 ParseFileAndExtractVideoFormat(
+// static
+int64 FileVideoCaptureDevice::ParseFileAndExtractVideoFormat(
     base::File* file,
     media::VideoCaptureFormat* video_format) {
   std::string header(kY4MHeaderMaxSize, 0);
   file->Read(0, &header[0], kY4MHeaderMaxSize - 1);
 
   size_t header_end = header.find(kY4MSimpleFrameDelimiter);
   CHECK_NE(header_end, header.npos);
 
   ParseY4MTags(header, video_format);
   return header_end + kY4MSimpleFrameDelimiterSize;
 }
 
 // Opens a given file for reading, and returns the file to the caller, who is
 // responsible for closing it.
-base::File OpenFileForRead(const base::FilePath& file_path) {
+// static
+base::File FileVideoCaptureDevice::OpenFileForRead(
+    const base::FilePath& file_path) {
   base::File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   CHECK(file.IsValid()) << file_path.value();
   return file.Pass();
 }
 
-// Inspects the command line and retrieves the file path parameter.
-base::FilePath GetFilePathFromCommandLine() {
-  base::FilePath command_line_file_path =
-      CommandLine::ForCurrentProcess()->GetSwitchValuePath(
-          switches::kUseFileForFakeVideoCapture);
-  CHECK(!command_line_file_path.empty());
-  return command_line_file_path;
-}
-
-void FileVideoCaptureDevice::GetDeviceNames(Names* const device_names) {
-  DCHECK(device_names->empty());
-  base::FilePath command_line_file_path = GetFilePathFromCommandLine();
-#if defined(OS_WIN)
-  device_names->push_back(
-      Name(base::SysWideToUTF8(command_line_file_path.value()),
-           kFileVideoCaptureDeviceName));
-#else
-  device_names->push_back(Name(command_line_file_path.value(),
-                               kFileVideoCaptureDeviceName));
-#endif  // OS_WIN
-}
-
-void FileVideoCaptureDevice::GetDeviceSupportedFormats(
-    const Name& device,
-    VideoCaptureFormats* supported_formats) {
-  base::File file = OpenFileForRead(GetFilePathFromCommandLine());
-  VideoCaptureFormat capture_format;
-  ParseFileAndExtractVideoFormat(&file, &capture_format);
-  supported_formats->push_back(capture_format);
-}
-
-VideoCaptureDevice* FileVideoCaptureDevice::Create(const Name& device_name) {
-#if defined(OS_WIN)
-  return new FileVideoCaptureDevice(
-      base::FilePath(base::SysUTF8ToWide(device_name.name())));
-#else
-  return new FileVideoCaptureDevice(base::FilePath(device_name.name()));
-#endif  // OS_WIN
-}
-
 FileVideoCaptureDevice::FileVideoCaptureDevice(const base::FilePath& file_path)
     : capture_thread_("CaptureThread"),
       file_path_(file_path),
       frame_size_(0),
       current_byte_index_(0),
       first_frame_byte_index_(0) {}
 
 FileVideoCaptureDevice::~FileVideoCaptureDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Check if the thread is running.
@@ skipping 97 matching lines @@
                                   base::TimeTicks::Now());
   // Reschedule next CaptureTask.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FileVideoCaptureDevice::OnCaptureTask,
                  base::Unretained(this)),
       base::TimeDelta::FromSeconds(1) / capture_format_.frame_rate);
 }
 
 }  // namespace media