content_browser_client.h 7.69 KB
Newer Older
1 2 3 4 5 6 7 8
// Copyright (c) 2011 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.

#ifndef CEF_LIBCEF_BROWSER_CONTENT_BROWSER_CLIENT_H_
#define CEF_LIBCEF_BROWSER_CONTENT_BROWSER_CLIENT_H_
#pragma once

9
#include <list>
10
#include <map>
11
#include <set>
12 13 14
#include <string>
#include <utility>

15
#include "include/cef_request_context_handler.h"
16 17
#include "libcef/browser/browser_context_impl.h"
#include "libcef/browser/url_request_context_getter_impl.h"
18

19
#include "base/compiler_specific.h"
20
#include "base/memory/ref_counted.h"
21
#include "base/memory/scoped_ptr.h"
22
#include "base/synchronization/lock.h"
23
#include "content/public/browser/content_browser_client.h"
24
#include "net/proxy/proxy_config_service.h"
25
#include "url/gurl.h"
26

27
class CefBrowserInfo;
28
class CefBrowserMainParts;
29
class CefDevToolsDelegate;
30
class CefResourceDispatcherHostDelegate;
31
class PrefService;
32 33

namespace content {
34
class PluginServiceFilter;
35 36 37 38 39 40
class SiteInstance;
}

class CefContentBrowserClient : public content::ContentBrowserClient {
 public:
  CefContentBrowserClient();
41
  ~CefContentBrowserClient() override;
42

43 44 45
  // Returns the singleton CefContentBrowserClient instance.
  static CefContentBrowserClient* Get();

46 47
  // Methods for managing CefBrowserInfo life span. Do not add new callers of
  // these methods.
48 49
  // During popup window creation there is a race between the call to
  // CefBrowserMessageFilter::OnGetNewBrowserInfo on the IO thread and the call
50 51 52
  // to CefBrowserHostImpl::ShouldCreateWebContents on the UI thread. To resolve
  // this race CefBrowserInfo may be created when requested for the first time
  // and before the associated CefBrowserHostImpl is created.
53
  scoped_refptr<CefBrowserInfo> CreateBrowserInfo(bool is_popup);
54 55 56 57 58
  scoped_refptr<CefBrowserInfo> GetOrCreateBrowserInfo(
      int render_view_process_id,
      int render_view_routing_id,
      int render_frame_process_id,
      int render_frame_routing_id);
59 60 61 62 63
  void RemoveBrowserInfo(scoped_refptr<CefBrowserInfo> browser_info);
  void DestroyAllBrowsers();

  // Retrieves the CefBrowserInfo matching the specified IDs or an empty
  // pointer if no match is found. It is allowed to add new callers of this
64
  // method but consider using CefBrowserHostImpl::GetBrowserFor[View|Frame]()
65
  // instead.
66 67 68 69
  scoped_refptr<CefBrowserInfo> GetBrowserInfoForView(int render_process_id,
                                                      int render_routing_id);
  scoped_refptr<CefBrowserInfo> GetBrowserInfoForFrame(int render_process_id,
                                                       int render_routing_id);
70

71
  // ContentBrowserClient implementation.
72 73 74 75 76
  content::BrowserMainParts* CreateBrowserMainParts(
      const content::MainFunctionParams& parameters) override;
  void RenderProcessWillLaunch(
      content::RenderProcessHost* host) override;
  net::URLRequestContextGetter* CreateRequestContext(
77
      content::BrowserContext* browser_context,
78
      content::ProtocolHandlerMap* protocol_handlers,
79
      content::URLRequestInterceptorScopedVector request_interceptors)
80 81
      override;
  net::URLRequestContextGetter* CreateRequestContextForStoragePartition(
82 83 84
      content::BrowserContext* browser_context,
      const base::FilePath& partition_path,
      bool in_memory,
85
      content::ProtocolHandlerMap* protocol_handlers,
86
      content::URLRequestInterceptorScopedVector request_interceptors)
87 88 89 90 91 92 93 94
      override;
  bool IsHandledURL(const GURL& url) override;
  void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
                                              int child_process_id) override;
  content::QuotaPermissionContext*
      CreateQuotaPermissionContext() override;
  content::MediaObserver* GetMediaObserver() override;
  content::SpeechRecognitionManagerDelegate*
95
      CreateSpeechRecognitionManagerDelegate() override;
96
  void AllowCertificateError(
97
      int render_process_id,
98
      int render_frame_id,
99 100 101
      int cert_error,
      const net::SSLInfo& ssl_info,
      const GURL& request_url,
102
      content::ResourceType resource_type,
103 104
      bool overridable,
      bool strict_enforcement,
105
      bool expired_previous_decision,
106
      const base::Callback<void(bool)>& callback,
107 108 109 110
      content::CertificateRequestResultType* result) override;
  content::AccessTokenStore* CreateAccessTokenStore() override;
  void RequestPermission(
      content::PermissionType permission,
111 112 113 114
      content::WebContents* web_contents,
      int bridge_id,
      const GURL& requesting_frame,
      bool user_gesture,
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
      const base::Callback<void(bool)>& result_callback) override;
  void CancelPermissionRequest(content::PermissionType permission,
                                       content::WebContents* web_contents,
                                       int bridge_id,
                                       const GURL& requesting_frame) override;
  bool CanCreateWindow(const GURL& opener_url,
                       const GURL& opener_top_level_frame_url,
                       const GURL& source_origin,
                       WindowContainerType container_type,
                       const GURL& target_url,
                       const content::Referrer& referrer,
                       WindowOpenDisposition disposition,
                       const blink::WebWindowFeatures& features,
                       bool user_gesture,
                       bool opener_suppressed,
                       content::ResourceContext* context,
                       int render_process_id,
                       int opener_id,
                       bool* no_javascript_access) override;
  void ResourceDispatcherHostCreated() override;
  void OverrideWebkitPrefs(content::RenderViewHost* rvh,
                           const GURL& url,
                           content::WebPreferences* prefs) override;
  SkColor GetBaseBackgroundColor(content::RenderViewHost* rvh) override;
  void BrowserURLHandlerCreated(
      content::BrowserURLHandler* handler) override;
  std::string GetDefaultDownloadName() override;
  content::DevToolsManagerDelegate* GetDevToolsManagerDelegate()
      override;
144

145
#if defined(OS_POSIX) && !defined(OS_MACOSX)
146
  void GetAdditionalMappedFilesForChildProcess(
147
      const base::CommandLine& command_line,
148
      int child_process_id,
149
      content::FileDescriptorInfo* mappings) override;
150 151
#endif

152
#if defined(OS_WIN)
153
  const wchar_t* GetResourceDllName() override;
154
#endif
155

156 157
  // Perform browser process registration for the custom scheme.
  void RegisterCustomScheme(const std::string& scheme);
158

159 160 161
  // Store additional state from the ViewHostMsg_CreateWindow message that will
  // be used when CanCreateWindow() is called.
  struct LastCreateWindowParams {
162 163
    int opener_process_id;
    int opener_view_id;
164 165
    int64 opener_frame_id;
    GURL target_url;
166
    base::string16 target_frame_name;
167 168 169
  };
  void set_last_create_window_params(const LastCreateWindowParams& params);

170 171
  scoped_refptr<CefBrowserContextImpl> browser_context() const;
  scoped_refptr<CefURLRequestContextGetterImpl> request_context() const;
172 173
  CefDevToolsDelegate* devtools_delegate() const;
  PrefService* pref_service() const;
174

175 176 177 178
  // Passes ownership.
  scoped_ptr<net::ProxyConfigService> proxy_config_service() const;

 private:
179 180
  CefBrowserMainParts* browser_main_parts_;

181
  scoped_ptr<content::PluginServiceFilter> plugin_service_filter_;
182 183
  scoped_ptr<CefResourceDispatcherHostDelegate>
      resource_dispatcher_host_delegate_;
184

185
  base::Lock browser_info_lock_;
186

187 188 189 190
  // Access must be protected by |browser_info_lock_|.
  typedef std::list<scoped_refptr<CefBrowserInfo> > BrowserInfoList;
  BrowserInfoList browser_info_list_;
  int next_browser_id_;
191 192 193

  // Only accessed on the IO thread.
  LastCreateWindowParams last_create_window_params_;
194 195 196
};

#endif  // CEF_LIBCEF_BROWSER_CONTENT_BROWSER_CLIENT_H_