add components for integration test which will detect breakage of media pipeline with video captu...

webkit/support/webkit_support.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "webkit/support/webkit_support.h"
 
 #include "base/at_exit.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 39 matching lines @@
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webkitplatformsupport_impl.h"
 #include "webkit/media/video_renderer_impl.h"
 #include "webkit/media/webmediaplayer_impl.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/npapi/webplugin_impl.h"
 #include "webkit/plugins/npapi/webplugin_page_delegate.h"
 #include "webkit/plugins/webplugininfo.h"
 #include "webkit/support/platform_support.h"
 #include "webkit/support/simple_database_system.h"
+#include "webkit/support/test_media_stream_client.h"

[acolwell GONE FROM CHROMIUM, 2012/01/06 18:09:16]

nit: If you change CreateMediaPlayer() to take a MediaStreamClient, I don't
think you'll need this.

[wjia(left Chromium), 2012/01/06 22:18:59]

Done.

 #include "webkit/support/test_webkit_platform_support.h"
 #include "webkit/support/test_webplugin_page_delegate.h"
 #include "webkit/tools/test_shell/simple_file_system.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 using WebKit::WebCString;
 using WebKit::WebDevToolsAgentClient;
 using WebKit::WebFileSystem;
 using WebKit::WebFileSystemCallbacks;
 using WebKit::WebFrame;
@@ skipping 224 matching lines @@
       NULL, &plugins, &mime_types);
   if (plugins.empty())
     return NULL;
 
   WebPluginParams new_params = params;
   new_params.mimeType = WebString::fromUTF8(mime_types.front());
   return new WebPluginImplWithPageDelegate(
       frame, new_params, plugins.front().path);
 }
 
-WebKit::WebMediaPlayer* CreateMediaPlayer(WebFrame* frame,
-                                          WebMediaPlayerClient* client) {
+WebKit::WebMediaPlayer* CreateMediaPlayer(
+    WebFrame* frame,
+    WebMediaPlayerClient* client,
+    TestMediaStreamClient* test_media_stream_client) {
 #if defined(OS_ANDROID)
   // TODO: Implement the WebMediaPlayer that will be used for Android.
   return NULL;
 #else
   scoped_ptr<media::MessageLoopFactory> message_loop_factory(
       new media::MessageLoopFactoryImpl());
 
   scoped_ptr<media::FilterCollection> collection(
       new media::FilterCollection());
 
   scoped_ptr<webkit_media::WebMediaPlayerImpl> result(
       new webkit_media::WebMediaPlayerImpl(
           client,
           base::WeakPtr<webkit_media::WebMediaPlayerDelegate>(),
           collection.release(),
           message_loop_factory.release(),
-          NULL,
+          test_media_stream_client,
           new media::MediaLog()));
   if (!result->Initialize(frame, false)) {
     return NULL;
   }
   return result.release();
 #endif
 }
 
+WebKit::WebMediaPlayer* CreateMediaPlayer(
+    WebFrame* frame,
+    WebMediaPlayerClient* client) {
+  return CreateMediaPlayer(frame, client, NULL);
+}
+
 WebKit::WebApplicationCacheHost* CreateApplicationCacheHost(
     WebFrame*, WebKit::WebApplicationCacheHostClient* client) {
   return SimpleAppCacheSystem::CreateApplicationCacheHost(client);
 }
 
 WebKit::WebString GetWebKitRootDir() {
   FilePath path = GetWebKitRootDirFilePath();
   std::string path_ascii = path.MaybeAsASCII();
   CHECK(!path_ascii.empty());
   return WebKit::WebString::fromUTF8(path_ascii.c_str());
 }
 
 void SetUpGLBindings(GLBindingPreferences bindingPref) {
-  switch(bindingPref) {
+  switch (bindingPref) {
     case GL_BINDING_DEFAULT:
       gfx::GLSurface::InitializeOneOff();
       break;
     case GL_BINDING_SOFTWARE_RENDERER:
       gfx::InitializeGLBindings(gfx::kGLImplementationOSMesaGL);
       break;
     default:
       NOTREACHED();
   }
 }
@@ skipping 149 matching lines @@
     return WebURL();
 
   const char kDataUrlPrefix[] = "data:text/css;charset=utf-8;base64,";
   return WebURL(GURL(kDataUrlPrefix + contents_base64));
 }
 
 // A wrapper object for exporting ScopedTempDir to be used
 // by webkit layout tests.
 class ScopedTempDirectoryInternal : public ScopedTempDirectory {
  public:
-   virtual bool CreateUniqueTempDir() {
-     return tempDirectory_.CreateUniqueTempDir();
-   }
+  virtual bool CreateUniqueTempDir() {
+    return tempDirectory_.CreateUniqueTempDir();
+  }
 
-   virtual std::string path() const {
-     return tempDirectory_.path().MaybeAsASCII();
-   }
+  virtual std::string path() const {
+    return tempDirectory_.path().MaybeAsASCII();
+  }
 
  private:
-   ScopedTempDir tempDirectory_;
+  ScopedTempDir tempDirectory_;
 };
 
 ScopedTempDirectory* CreateScopedTempDirectory() {
   return new ScopedTempDirectoryInternal();
 }
 
 int64 GetCurrentTimeInMillisecond() {
   return base::TimeTicks::Now().ToInternalValue()
       / base::Time::kMicrosecondsPerMillisecond;
 }
@@ skipping 17 matching lines @@
       // make this translation here to match the behavior of stock WebKit.
       domain = "WebKitErrorDomain";
       code = 103;
       break;
     case net::ERR_ADDRESS_INVALID:
     case net::ERR_ADDRESS_UNREACHABLE:
     case net::ERR_NETWORK_ACCESS_DENIED:
       code = -1004;  // NSURLErrorCannotConnectToHost
       break;
     }
-  } else
+  } else {
     DLOG(WARNING) << "Unknown error domain";
+  }
 
   return base::StringPrintf("<NSError domain %s, code %d, failing URL \"%s\">",
       domain.c_str(), code, error.unreachableURL.spec().data());
 }
 
 WebKit::WebURLError CreateCancelledError(const WebKit::WebURLRequest& request) {
   WebKit::WebURLError error;
   error.domain = WebKit::WebString::fromUTF8(net::kErrorDomain);
   error.reason = net::ERR_ABORTED;
   error.unreachableURL = request.url();
@@ skipping 67 matching lines @@
 // Logging
 void EnableWebCoreLogChannels(const std::string& channels) {
   webkit_glue::EnableWebCoreLogChannels(channels);
 }
 
 void SetGamepadData(const WebKit::WebGamepads& pads) {
   test_environment->webkit_platform_support()->setGamepadData(pads);
 }
 
 }  // namespace webkit_support