media: Optimize HW Video to 2D Canvas copy.

content/renderer/render_frame_impl.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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 133 matching lines @@
 
 #if defined(OS_ANDROID)
 #include <cpu-features.h>
 
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/renderer/android/synchronous_compositor_factory.h"
 #include "content/renderer/java/gin_java_bridge_dispatcher.h"
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #include "content/renderer/media/android/stream_texture_factory_impl.h"
 #include "content/renderer/media/android/webmediaplayer_android.h"
+#else
+#include "webkit/common/gpu/context_provider_web_context.h"
 #endif
 
 #if defined(ENABLE_PEPPER_CDMS)
 #include "content/renderer/media/crypto/pepper_cdm_wrapper_impl.h"
 #elif defined(ENABLE_BROWSER_CDMS)
 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
 #endif
 
 using blink::WebContextMenuData;
 using blink::WebData;
@@ skipping 75 matching lines @@
     if (urls[i] != GURL(kSwappedOutURL))
       result->push_back(urls[i]);
     else
       result->push_back(blank_url);
   }
 }
 
 // Returns the original request url. If there is no redirect, the original
 // url is the same as ds->request()->url(). If the WebDataSource belongs to a
 // frame was loaded by loadData, the original url will be ds->unreachableURL()
-static GURL GetOriginalRequestURL(WebDataSource* ds) {
+GURL GetOriginalRequestURL(WebDataSource* ds) {
   // WebDataSource has unreachable URL means that the frame is loaded through
   // blink::WebFrame::loadData(), and the base URL will be in the redirect
   // chain. However, we never visited the baseURL. So in this case, we should
   // use the unreachable URL as the original URL.
   if (ds->hasUnreachableURL())
     return ds->unreachableURL();
 
   std::vector<GURL> redirects;
   GetRedirectChain(ds, &redirects);
   if (!redirects.empty())
     return redirects.at(0);
 
   return ds->originalRequest().url();
 }
 
-NOINLINE static void CrashIntentionally() {
+NOINLINE void CrashIntentionally() {
   // NOTE(shess): Crash directly rather than using NOTREACHED() so
   // that the signature is easier to triage in crash reports.
   volatile int* zero = NULL;
   *zero = 0;
 }
 
 #if defined(ADDRESS_SANITIZER) || defined(SYZYASAN)
-NOINLINE static void MaybeTriggerAsanError(const GURL& url) {
+NOINLINE void MaybeTriggerAsanError(const GURL& url) {
   // NOTE(rogerm): We intentionally perform an invalid heap access here in
   //     order to trigger an Address Sanitizer (ASAN) error report.
   const char kCrashDomain[] = "crash";
   const char kHeapOverflow[] = "/heap-overflow";
   const char kHeapUnderflow[] = "/heap-underflow";
   const char kUseAfterFree[] = "/use-after-free";
 #if defined(SYZYASAN)
   const char kCorruptHeapBlock[] = "/corrupt-heap-block";
   const char kCorruptHeap[] = "/corrupt-heap";
 #endif
@@ skipping 14 matching lines @@
 #if defined(SYZYASAN)
   } else if (crash_type == kCorruptHeapBlock) {
     base::debug::AsanCorruptHeapBlock();
   } else if (crash_type == kCorruptHeap) {
     base::debug::AsanCorruptHeap();
 #endif
   }
 }
 #endif  // ADDRESS_SANITIZER || SYZYASAN
 
-static void MaybeHandleDebugURL(const GURL& url) {
+void MaybeHandleDebugURL(const GURL& url) {
   if (!url.SchemeIs(kChromeUIScheme))
     return;
   if (url == GURL(kChromeUICrashURL)) {
     CrashIntentionally();
   } else if (url == GURL(kChromeUIDumpURL)) {
     // This URL will only correctly create a crash dump file if content is
     // hosted in a process that has correctly called
     // base::debug::SetDumpWithoutCrashingFunction.  Refer to the documentation
     // of base::debug::DumpWithoutCrashing for more details.
     base::debug::DumpWithoutCrashing();
   } else if (url == GURL(kChromeUIKillURL)) {
     base::KillProcess(base::GetCurrentProcessHandle(), 1, false);
   } else if (url == GURL(kChromeUIHangURL)) {
     for (;;) {
       base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
     }
   } else if (url == GURL(kChromeUIShorthangURL)) {
     base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   }
 
 #if defined(ADDRESS_SANITIZER) || defined(SYZYASAN)
   MaybeTriggerAsanError(url);
 #endif  // ADDRESS_SANITIZER || SYZYASAN
 }
 
 // Returns false unless this is a top-level navigation.
-static bool IsTopLevelNavigation(WebFrame* frame) {
+bool IsTopLevelNavigation(WebFrame* frame) {
   return frame->parent() == NULL;
 }
 
 // Returns false unless this is a top-level navigation that crosses origins.
-static bool IsNonLocalTopLevelNavigation(const GURL& url,
-                                         WebFrame* frame,
-                                         WebNavigationType type,
-                                         bool is_form_post) {
+bool IsNonLocalTopLevelNavigation(const GURL& url,
+                                  WebFrame* frame,
+                                  WebNavigationType type,
+                                  bool is_form_post) {
   if (!IsTopLevelNavigation(frame))
     return false;
 
   // Navigations initiated within Webkit are not sent out to the external host
   // in the following cases.
   // 1. The url scheme is not http/https
   // 2. The origin of the url and the opener is the same in which case the
   //    opener relationship is maintained.
   // 3. Reloads/form submits/back forward navigations
   if (!url.SchemeIs(url::kHttpScheme) && !url.SchemeIs(url::kHttpsScheme))
@@ skipping 111 matching lines @@
     extra_data = &kEmptyData;
   CommonNavigationParams params;
   params.url = request.url();
   params.referrer = Referrer(
       GURL(request.httpHeaderField(WebString::fromUTF8("Referer")).latin1()),
       request.referrerPolicy());
   params.transition = extra_data->transition_type();
   return params;
 }
 
+#if !defined(OS_ANDROID)
+media::Context3DProvider GetSharedMainThreadContext3DProvider() {
+  RenderThreadImpl* render_thread = RenderThreadImpl::current();
+  DCHECK(render_thread);

[scherkus (not reviewing), 2014/10/30 20:40:11]

nit: I'm not sure how useful these DCHECKs are in practice as current() will
return nullptr if you don't access this on the right thread (it relies on TLS)

we also dereference on line 483 -- so we're essentially checking for the same
condition multiple times in a variety of different ways

[dshwang, 2014/10/31 09:29:16]

I agree. I removed DCHECKs.

+  DCHECK(render_thread->message_loop() == base::MessageLoop::current());
+  cc::ContextProvider* provider =
+      render_thread->SharedMainThreadContextProvider().get();
+  if (!provider)
+    return {nullptr, nullptr};
+  return {provider->ContextGL(), provider->GrContext()};
+}
+#endif
+
+RenderFrameImpl* (*g_create_render_frame_impl)(RenderViewImpl*,
+                                               int32) = nullptr;
+
 }  // namespace
 
-static RenderFrameImpl* (*g_create_render_frame_impl)(RenderViewImpl*, int32) =
-    NULL;
 
 // static
 RenderFrameImpl* RenderFrameImpl::Create(RenderViewImpl* render_view,
                                          int32 routing_id) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
 
   if (g_create_render_frame_impl)
     return g_create_render_frame_impl(render_view, routing_id);
   else
     return new RenderFrameImpl(render_view, routing_id);
@@ skipping 1206 matching lines @@
                  base::Unretained(GetContentClient()->renderer()),
                  static_cast<RenderFrame*>(this)),
       render_thread->GetAudioRendererMixerManager()->CreateInput(
           render_view_->routing_id_, routing_id_),
       *render_thread->GetAudioHardwareConfig(),
       new RenderMediaLog(),
       render_thread->GetGpuFactories(),
       render_thread->GetMediaThreadTaskRunner(),
       render_thread->compositor_message_loop_proxy(),
       base::Bind(&EncryptedMediaPlayerSupportImpl::Create),
+      base::Bind(&GetSharedMainThreadContext3DProvider),
       initial_cdm);
   return new media::WebMediaPlayerImpl(
       frame, client, weak_factory_.GetWeakPtr(), nullptr, params);
 #endif  // defined(OS_ANDROID)
 }
 
 blink::WebContentDecryptionModule*
 RenderFrameImpl::createContentDecryptionModule(
     blink::WebLocalFrame* frame,
     const blink::WebSecurityOrigin& security_origin,
@@ skipping 2411 matching lines @@
 
 #if defined(ENABLE_BROWSER_CDMS)
 RendererCdmManager* RenderFrameImpl::GetCdmManager() {
   if (!cdm_manager_)
     cdm_manager_ = new RendererCdmManager(this);
   return cdm_manager_;
 }
 #endif  // defined(ENABLE_BROWSER_CDMS)
 
 }  // namespace content