1 // Copyright (c) 2013 The Chromium Embedded Framework Authors. 2 // Portions copyright (c) 2011 The Chromium Authors. All rights reserved. 3 // Use of this source code is governed by a BSD-style license that can be 4 // found in the LICENSE file. 5 6 #ifndef CEF_LIBCEF_RENDERER_ALLOY_ALLOY_CONTENT_RENDERER_CLIENT_H_ 7 #define CEF_LIBCEF_RENDERER_ALLOY_ALLOY_CONTENT_RENDERER_CLIENT_H_ 8 #pragma once 9 10 #include <list> 11 #include <map> 12 #include <memory> 13 #include <string> 14 #include <vector> 15 16 #include "libcef/renderer/browser_impl.h" 17 18 #include "base/compiler_specific.h" 19 #include "base/single_thread_task_runner.h" 20 #include "base/task/current_thread.h" 21 #include "chrome/common/plugin.mojom.h" 22 #include "content/public/renderer/content_renderer_client.h" 23 #include "content/public/renderer/render_thread.h" 24 #include "mojo/public/cpp/bindings/generic_pending_receiver.h" 25 #include "services/service_manager/public/cpp/local_interface_provider.h" 26 27 namespace extensions { 28 class CefExtensionsRendererClient; 29 class Dispatcher; 30 class DispatcherDelegate; 31 class ExtensionsClient; 32 class ExtensionsGuestViewContainerDispatcher; 33 class ExtensionsRendererClient; 34 class ResourceRequestPolicy; 35 } // namespace extensions 36 37 namespace visitedlink { 38 class VisitedLinkReader; 39 } 40 41 namespace web_cache { 42 class WebCacheImpl; 43 } 44 45 class CefBrowserManager; 46 class CefRenderThreadObserver; 47 class ChromePDFPrintClient; 48 class SpellCheck; 49 50 class AlloyContentRendererClient 51 : public content::ContentRendererClient, 52 public service_manager::LocalInterfaceProvider, 53 public base::CurrentThread::DestructionObserver { 54 public: 55 AlloyContentRendererClient(); 56 ~AlloyContentRendererClient() override; 57 58 // Returns the singleton AlloyContentRendererClient instance. 59 // This method is deprecated and should not be used in new callsites. 60 static AlloyContentRendererClient* Get(); 61 62 // Render thread task runner. render_task_runner()63 base::SingleThreadTaskRunner* render_task_runner() const { 64 return render_task_runner_.get(); 65 } 66 67 // Returns the task runner for the current thread. Returns NULL if the current 68 // thread is not the main render process thread. 69 scoped_refptr<base::SingleThreadTaskRunner> GetCurrentTaskRunner(); 70 71 // Perform cleanup work that needs to occur before shutdown when running in 72 // single-process mode. Blocks until cleanup is complete. 73 void RunSingleProcessCleanup(); 74 75 // ContentRendererClient implementation. 76 void PostIOThreadCreated( 77 base::SingleThreadTaskRunner* io_thread_task_runner) override; 78 void RenderThreadStarted() override; 79 void ExposeInterfacesToBrowser(mojo::BinderMap* binders) override; 80 void RenderThreadConnected() override; 81 void RenderFrameCreated(content::RenderFrame* render_frame) override; 82 void RenderViewCreated(content::RenderView* render_view) override; 83 bool IsPluginHandledExternally(content::RenderFrame* render_frame, 84 const blink::WebElement& plugin_element, 85 const GURL& original_url, 86 const std::string& mime_type) override; 87 bool OverrideCreatePlugin(content::RenderFrame* render_frame, 88 const blink::WebPluginParams& params, 89 blink::WebPlugin** plugin) override; 90 void WillSendRequest(blink::WebLocalFrame* frame, 91 ui::PageTransition transition_type, 92 const blink::WebURL& url, 93 const net::SiteForCookies& site_for_cookies, 94 const url::Origin* initiator_origin, 95 GURL* new_url) override; 96 uint64_t VisitedLinkHash(const char* canonical_url, size_t length) override; 97 bool IsLinkVisited(uint64_t link_hash) override; 98 bool IsOriginIsolatedPepperPlugin(const base::FilePath& plugin_path) override; 99 void AddSupportedKeySystems( 100 std::vector<std::unique_ptr<::media::KeySystemProperties>>* key_systems) 101 override; 102 void RunScriptsAtDocumentStart(content::RenderFrame* render_frame) override; 103 void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame) override; 104 void RunScriptsAtDocumentIdle(content::RenderFrame* render_frame) override; 105 void DevToolsAgentAttached() override; 106 void DevToolsAgentDetached() override; 107 std::unique_ptr<blink::URLLoaderThrottleProvider> 108 CreateURLLoaderThrottleProvider( 109 blink::URLLoaderThrottleProviderType provider_type) override; 110 111 // service_manager::LocalInterfaceProvider implementation. 112 void GetInterface(const std::string& name, 113 mojo::ScopedMessagePipeHandle request_handle) override; 114 115 // MessageLoopCurrent::DestructionObserver implementation. 116 void WillDestroyCurrentMessageLoop() override; 117 118 private: 119 void OnBrowserCreated(content::RenderView* render_view, 120 base::Optional<bool> is_windowless); 121 122 // Perform cleanup work for single-process mode. 123 void RunSingleProcessCleanupOnUIThread(); 124 125 // Time at which this object was created. This is very close to the time at 126 // which the RendererMain function was entered. 127 base::TimeTicks main_entry_time_; 128 129 std::unique_ptr<CefBrowserManager> browser_manager_; 130 131 scoped_refptr<base::SingleThreadTaskRunner> render_task_runner_; 132 std::unique_ptr<CefRenderThreadObserver> observer_; 133 std::unique_ptr<web_cache::WebCacheImpl> web_cache_impl_; 134 std::unique_ptr<SpellCheck> spellcheck_; 135 std::unique_ptr<visitedlink::VisitedLinkReader> visited_link_slave_; 136 137 std::unique_ptr<ChromePDFPrintClient> pdf_print_client_; 138 139 std::unique_ptr<extensions::ExtensionsClient> extensions_client_; 140 std::unique_ptr<extensions::CefExtensionsRendererClient> 141 extensions_renderer_client_; 142 143 // Used in single-process mode to test when cleanup is complete. 144 // Access must be protected by |single_process_cleanup_lock_|. 145 bool single_process_cleanup_complete_ = false; 146 base::Lock single_process_cleanup_lock_; 147 148 DISALLOW_COPY_AND_ASSIGN(AlloyContentRendererClient); 149 }; 150 151 #endif // CEF_LIBCEF_RENDERER_ALLOY_ALLOY_CONTENT_RENDERER_CLIENT_H_ 152