web_contents.h revision 6e8cce623b6e4fe0c9e4af605d675dd9d0338c38
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef CONTENT_PUBLIC_BROWSER_WEB_CONTENTS_H_ 6#define CONTENT_PUBLIC_BROWSER_WEB_CONTENTS_H_ 7 8#include <set> 9 10#include "base/basictypes.h" 11#include "base/callback_forward.h" 12#include "base/files/file_path.h" 13#include "base/process/kill.h" 14#include "base/strings/string16.h" 15#include "base/supports_user_data.h" 16#include "content/common/content_export.h" 17#include "content/public/browser/invalidate_type.h" 18#include "content/public/browser/navigation_controller.h" 19#include "content/public/browser/page_navigator.h" 20#include "content/public/browser/save_page_type.h" 21#include "content/public/browser/web_ui.h" 22#include "content/public/common/stop_find_action.h" 23#include "ipc/ipc_sender.h" 24#include "third_party/skia/include/core/SkColor.h" 25#include "ui/base/window_open_disposition.h" 26#include "ui/gfx/native_widget_types.h" 27#include "ui/gfx/rect.h" 28 29#if defined(OS_ANDROID) 30#include "base/android/scoped_java_ref.h" 31#endif 32 33namespace base { 34class DictionaryValue; 35class TimeTicks; 36} 37 38namespace blink { 39struct WebFindOptions; 40} 41 42namespace net { 43struct LoadStateWithParam; 44} 45 46namespace content { 47 48class BrowserContext; 49class BrowserPluginGuestDelegate; 50class InterstitialPage; 51class PageState; 52class RenderFrameHost; 53class RenderProcessHost; 54class RenderViewHost; 55class RenderWidgetHostView; 56class SiteInstance; 57class WebContentsDelegate; 58struct CustomContextMenuContext; 59struct DropData; 60struct RendererPreferences; 61 62// WebContents is the core class in content/. A WebContents renders web content 63// (usually HTML) in a rectangular area. 64// 65// Instantiating one is simple: 66// scoped_ptr<content::WebContents> web_contents( 67// content::WebContents::Create( 68// content::WebContents::CreateParams(browser_context))); 69// gfx::NativeView view = web_contents->GetNativeView(); 70// // |view| is an HWND, NSView*, GtkWidget*, etc.; insert it into the view 71// // hierarchy wherever it needs to go. 72// 73// That's it; go to your kitchen, grab a scone, and chill. WebContents will do 74// all the multi-process stuff behind the scenes. More details are at 75// http://www.chromium.org/developers/design-documents/multi-process-architecture . 76// 77// Each WebContents has exactly one NavigationController; each 78// NavigationController belongs to one WebContents. The NavigationController can 79// be obtained from GetController(), and is used to load URLs into the 80// WebContents, navigate it backwards/forwards, etc. See navigation_controller.h 81// for more details. 82class WebContents : public PageNavigator, 83 public IPC::Sender, 84 public base::SupportsUserData { 85 public: 86 struct CONTENT_EXPORT CreateParams { 87 explicit CreateParams(BrowserContext* context); 88 ~CreateParams(); 89 CreateParams(BrowserContext* context, SiteInstance* site); 90 91 BrowserContext* browser_context; 92 93 // Specifying a SiteInstance here is optional. It can be set to avoid an 94 // extra process swap if the first navigation is expected to require a 95 // privileged process. 96 SiteInstance* site_instance; 97 98 // The opener WebContents is the WebContents that initiated this request, 99 // if any. 100 WebContents* opener; 101 102 // If the opener is suppressed, then the new WebContents doesn't hold a 103 // reference to its opener. 104 bool opener_suppressed; 105 int routing_id; 106 int main_frame_routing_id; 107 108 // Initial size of the new WebContent's view. Can be (0, 0) if not needed. 109 gfx::Size initial_size; 110 111 // True if the contents should be initially hidden. 112 bool initially_hidden; 113 114 // If non-null then this WebContents will be hosted by a BrowserPlugin. 115 BrowserPluginGuestDelegate* guest_delegate; 116 117 // Used to specify the location context which display the new view should 118 // belong. This can be NULL if not needed. 119 gfx::NativeView context; 120 }; 121 122 // Creates a new WebContents. 123 CONTENT_EXPORT static WebContents* Create(const CreateParams& params); 124 125 // Similar to Create() above but should be used when you need to prepopulate 126 // the SessionStorageNamespaceMap of the WebContents. This can happen if 127 // you duplicate a WebContents, try to reconstitute it from a saved state, 128 // or when you create a new WebContents based on another one (eg., when 129 // servicing a window.open() call). 130 // 131 // You do not want to call this. If you think you do, make sure you completely 132 // understand when SessionStorageNamespace objects should be cloned, why 133 // they should not be shared by multiple WebContents, and what bad things 134 // can happen if you share the object. 135 CONTENT_EXPORT static WebContents* CreateWithSessionStorage( 136 const CreateParams& params, 137 const SessionStorageNamespaceMap& session_storage_namespace_map); 138 139 // Returns a WebContents that wraps the RenderViewHost, or NULL if the 140 // render view host's delegate isn't a WebContents. 141 CONTENT_EXPORT static WebContents* FromRenderViewHost( 142 const RenderViewHost* rvh); 143 144 CONTENT_EXPORT static WebContents* FromRenderFrameHost(RenderFrameHost* rfh); 145 146 virtual ~WebContents() {} 147 148 // Intrinsic tab state ------------------------------------------------------- 149 150 // Gets/Sets the delegate. 151 virtual WebContentsDelegate* GetDelegate() = 0; 152 virtual void SetDelegate(WebContentsDelegate* delegate) = 0; 153 154 // Gets the controller for this WebContents. 155 virtual NavigationController& GetController() = 0; 156 virtual const NavigationController& GetController() const = 0; 157 158 // Returns the user browser context associated with this WebContents (via the 159 // NavigationController). 160 virtual content::BrowserContext* GetBrowserContext() const = 0; 161 162 // Gets the URL that is currently being displayed, if there is one. 163 // This method is deprecated. DO NOT USE! Pick either |GetVisibleURL| or 164 // |GetLastCommittedURL| as appropriate. 165 virtual const GURL& GetURL() const = 0; 166 167 // Gets the URL currently being displayed in the URL bar, if there is one. 168 // This URL might be a pending navigation that hasn't committed yet, so it is 169 // not guaranteed to match the current page in this WebContents. A typical 170 // example of this is interstitials, which show the URL of the new/loading 171 // page (active) but the security context is of the old page (last committed). 172 virtual const GURL& GetVisibleURL() const = 0; 173 174 // Gets the last committed URL. It represents the current page that is 175 // displayed in this WebContents. It represents the current security 176 // context. 177 virtual const GURL& GetLastCommittedURL() const = 0; 178 179 // Return the currently active RenderProcessHost and RenderViewHost. Each of 180 // these may change over time. 181 virtual RenderProcessHost* GetRenderProcessHost() const = 0; 182 183 // Returns the main frame for the currently active view. 184 virtual RenderFrameHost* GetMainFrame() = 0; 185 186 // Returns the focused frame for the currently active view. 187 virtual RenderFrameHost* GetFocusedFrame() = 0; 188 189 // Calls |on_frame| for each frame in the currently active view. 190 virtual void ForEachFrame( 191 const base::Callback<void(RenderFrameHost*)>& on_frame) = 0; 192 193 // Sends the given IPC to all frames in the currently active view. This is a 194 // convenience method instead of calling ForEach. 195 virtual void SendToAllFrames(IPC::Message* message) = 0; 196 197 // Gets the current RenderViewHost for this tab. 198 virtual RenderViewHost* GetRenderViewHost() const = 0; 199 200 // Gets the current RenderViewHost's routing id. Returns 201 // MSG_ROUTING_NONE when there is no RenderViewHost. 202 virtual int GetRoutingID() const = 0; 203 204 // Returns the currently active RenderWidgetHostView. This may change over 205 // time and can be NULL (during setup and teardown). 206 virtual RenderWidgetHostView* GetRenderWidgetHostView() const = 0; 207 208 // Returns the currently active fullscreen widget. If there is none, returns 209 // NULL. 210 virtual RenderWidgetHostView* GetFullscreenRenderWidgetHostView() const = 0; 211 212 // Create a WebUI page for the given url. In most cases, this doesn't need to 213 // be called by embedders since content will create its own WebUI objects as 214 // necessary. However if the embedder wants to create its own WebUI object and 215 // keep track of it manually, it can use this. 216 virtual WebUI* CreateWebUI(const GURL& url) = 0; 217 218 // Returns the committed WebUI if one exists, otherwise the pending one. 219 virtual WebUI* GetWebUI() const = 0; 220 virtual WebUI* GetCommittedWebUI() const = 0; 221 222 // Allows overriding the user agent used for NavigationEntries it owns. 223 virtual void SetUserAgentOverride(const std::string& override) = 0; 224 virtual const std::string& GetUserAgentOverride() const = 0; 225 226 // Enable the accessibility tree for this WebContents in the renderer, 227 // but don't enable creating a native accessibility tree on the browser 228 // side. 229 virtual void EnableTreeOnlyAccessibilityMode() = 0; 230 231 // Returns true only if "tree only" accessibility mode is on. 232 virtual bool IsTreeOnlyAccessibilityModeForTesting() const = 0; 233 234 // Returns true only if complete accessibility mode is on, meaning there's 235 // both renderer accessibility, and a native browser accessibility tree. 236 virtual bool IsFullAccessibilityModeForTesting() const = 0; 237 238#if defined(OS_WIN) 239 virtual void SetParentNativeViewAccessible( 240 gfx::NativeViewAccessible accessible_parent) = 0; 241#endif 242 243 // Tab navigation state ------------------------------------------------------ 244 245 // Returns the current navigation properties, which if a navigation is 246 // pending may be provisional (e.g., the navigation could result in a 247 // download, in which case the URL would revert to what it was previously). 248 virtual const base::string16& GetTitle() const = 0; 249 250 // The max page ID for any page that the current SiteInstance has loaded in 251 // this WebContents. Page IDs are specific to a given SiteInstance and 252 // WebContents, corresponding to a specific RenderView in the renderer. 253 // Page IDs increase with each new page that is loaded by a tab. 254 virtual int32 GetMaxPageID() = 0; 255 256 // The max page ID for any page that the given SiteInstance has loaded in 257 // this WebContents. 258 virtual int32 GetMaxPageIDForSiteInstance(SiteInstance* site_instance) = 0; 259 260 // Returns the SiteInstance associated with the current page. 261 virtual SiteInstance* GetSiteInstance() const = 0; 262 263 // Returns the SiteInstance for the pending navigation, if any. Otherwise 264 // returns the current SiteInstance. 265 virtual SiteInstance* GetPendingSiteInstance() const = 0; 266 267 // Returns whether this WebContents is loading a resource. 268 virtual bool IsLoading() const = 0; 269 270 // Returns whether this WebContents is loading and and the load is to a 271 // different top-level document (rather than being a navigation within the 272 // same document). This being true implies that IsLoading() is also true. 273 virtual bool IsLoadingToDifferentDocument() const = 0; 274 275 // Returns whether this WebContents is waiting for a first-response for the 276 // main resource of the page. 277 virtual bool IsWaitingForResponse() const = 0; 278 279 // Returns the current load state and the URL associated with it. 280 virtual const net::LoadStateWithParam& GetLoadState() const = 0; 281 virtual const base::string16& GetLoadStateHost() const = 0; 282 283 // Returns the upload progress. 284 virtual uint64 GetUploadSize() const = 0; 285 virtual uint64 GetUploadPosition() const = 0; 286 287 // Returns a set of the site URLs currently committed in this tab. 288 virtual std::set<GURL> GetSitesInTab() const = 0; 289 290 // Returns the character encoding of the page. 291 virtual const std::string& GetEncoding() const = 0; 292 293 // True if this is a secure page which displayed insecure content. 294 virtual bool DisplayedInsecureContent() const = 0; 295 296 // Internal state ------------------------------------------------------------ 297 298 // Indicates whether the WebContents is being captured (e.g., for screenshots 299 // or mirroring). Increment calls must be balanced with an equivalent number 300 // of decrement calls. |capture_size| specifies the capturer's video 301 // resolution, but can be empty to mean "unspecified." The first screen 302 // capturer that provides a non-empty |capture_size| will override the value 303 // returned by GetPreferredSize() until all captures have ended. 304 virtual void IncrementCapturerCount(const gfx::Size& capture_size) = 0; 305 virtual void DecrementCapturerCount() = 0; 306 virtual int GetCapturerCount() const = 0; 307 308 // Indicates whether this tab should be considered crashed. The setter will 309 // also notify the delegate when the flag is changed. 310 virtual bool IsCrashed() const = 0; 311 virtual void SetIsCrashed(base::TerminationStatus status, int error_code) = 0; 312 313 virtual base::TerminationStatus GetCrashedStatus() const = 0; 314 315 // Whether the tab is in the process of being destroyed. 316 virtual bool IsBeingDestroyed() const = 0; 317 318 // Convenience method for notifying the delegate of a navigation state 319 // change. 320 virtual void NotifyNavigationStateChanged(InvalidateTypes changed_flags) = 0; 321 322 // Get the last time that the WebContents was made active (either when it was 323 // created or shown with WasShown()). 324 virtual base::TimeTicks GetLastActiveTime() const = 0; 325 326 // Invoked when the WebContents becomes shown/hidden. 327 virtual void WasShown() = 0; 328 virtual void WasHidden() = 0; 329 330 // Returns true if the before unload and unload listeners need to be 331 // fired. The value of this changes over time. For example, if true and the 332 // before unload listener is executed and allows the user to exit, then this 333 // returns false. 334 virtual bool NeedToFireBeforeUnload() = 0; 335 336 // Runs the beforeunload handler for the main frame. See also ClosePage and 337 // SwapOut in RenderViewHost, which run the unload handler. 338 // 339 // |for_cross_site_transition| indicates whether this call is for the current 340 // frame during a cross-process navigation. False means we're closing the 341 // entire tab. 342 // 343 // TODO(creis): We should run the beforeunload handler for every frame that 344 // has one. 345 virtual void DispatchBeforeUnload(bool for_cross_site_transition) = 0; 346 347 // Commands ------------------------------------------------------------------ 348 349 // Stop any pending navigation. 350 virtual void Stop() = 0; 351 352 // Creates a new WebContents with the same state as this one. The returned 353 // heap-allocated pointer is owned by the caller. 354 virtual WebContents* Clone() = 0; 355 356 // Reloads the focused frame. 357 virtual void ReloadFocusedFrame(bool ignore_cache) = 0; 358 359 // Editing commands ---------------------------------------------------------- 360 361 virtual void Undo() = 0; 362 virtual void Redo() = 0; 363 virtual void Cut() = 0; 364 virtual void Copy() = 0; 365 virtual void CopyToFindPboard() = 0; 366 virtual void Paste() = 0; 367 virtual void PasteAndMatchStyle() = 0; 368 virtual void Delete() = 0; 369 virtual void SelectAll() = 0; 370 virtual void Unselect() = 0; 371 372 // Replaces the currently selected word or a word around the cursor. 373 virtual void Replace(const base::string16& word) = 0; 374 375 // Replaces the misspelling in the current selection. 376 virtual void ReplaceMisspelling(const base::string16& word) = 0; 377 378 // Let the renderer know that the menu has been closed. 379 virtual void NotifyContextMenuClosed( 380 const CustomContextMenuContext& context) = 0; 381 382 // Executes custom context menu action that was provided from Blink. 383 virtual void ExecuteCustomContextMenuCommand( 384 int action, const CustomContextMenuContext& context) = 0; 385 386 // Views and focus ----------------------------------------------------------- 387 388 // Returns the native widget that contains the contents of the tab. 389 virtual gfx::NativeView GetNativeView() = 0; 390 391 // Returns the native widget with the main content of the tab (i.e. the main 392 // render view host, though there may be many popups in the tab as children of 393 // the container). 394 virtual gfx::NativeView GetContentNativeView() = 0; 395 396 // Returns the outermost native view. This will be used as the parent for 397 // dialog boxes. 398 virtual gfx::NativeWindow GetTopLevelNativeWindow() = 0; 399 400 // Computes the rectangle for the native widget that contains the contents of 401 // the tab in the screen coordinate system. 402 virtual gfx::Rect GetContainerBounds() = 0; 403 404 // Get the bounds of the View, relative to the parent. 405 virtual gfx::Rect GetViewBounds() = 0; 406 407 // Returns the current drop data, if any. 408 virtual DropData* GetDropData() = 0; 409 410 // Sets focus to the native widget for this tab. 411 virtual void Focus() = 0; 412 413 // Sets focus to the appropriate element when the WebContents is shown the 414 // first time. 415 virtual void SetInitialFocus() = 0; 416 417 // Stores the currently focused view. 418 virtual void StoreFocus() = 0; 419 420 // Restores focus to the last focus view. If StoreFocus has not yet been 421 // invoked, SetInitialFocus is invoked. 422 virtual void RestoreFocus() = 0; 423 424 // Focuses the first (last if |reverse| is true) element in the page. 425 // Invoked when this tab is getting the focus through tab traversal (|reverse| 426 // is true when using Shift-Tab). 427 virtual void FocusThroughTabTraversal(bool reverse) = 0; 428 429 // Interstitials ------------------------------------------------------------- 430 431 // Various other systems need to know about our interstitials. 432 virtual bool ShowingInterstitialPage() const = 0; 433 434 // Returns the currently showing interstitial, NULL if no interstitial is 435 // showing. 436 virtual InterstitialPage* GetInterstitialPage() const = 0; 437 438 // Misc state & callbacks ---------------------------------------------------- 439 440 // Check whether we can do the saving page operation this page given its MIME 441 // type. 442 virtual bool IsSavable() = 0; 443 444 // Prepare for saving the current web page to disk. 445 virtual void OnSavePage() = 0; 446 447 // Save page with the main HTML file path, the directory for saving resources, 448 // and the save type: HTML only or complete web page. Returns true if the 449 // saving process has been initiated successfully. 450 virtual bool SavePage(const base::FilePath& main_file, 451 const base::FilePath& dir_path, 452 SavePageType save_type) = 0; 453 454 // Saves the given frame's URL to the local filesystem.. 455 virtual void SaveFrame(const GURL& url, 456 const Referrer& referrer) = 0; 457 458 // Generate an MHTML representation of the current page in the given file. 459 virtual void GenerateMHTML( 460 const base::FilePath& file, 461 const base::Callback<void( 462 int64 /* size of the file */)>& callback) = 0; 463 464 // Returns the contents MIME type after a navigation. 465 virtual const std::string& GetContentsMimeType() const = 0; 466 467 // Returns true if this WebContents will notify about disconnection. 468 virtual bool WillNotifyDisconnection() const = 0; 469 470 // Override the encoding and reload the page by sending down 471 // ViewMsg_SetPageEncoding to the renderer. |UpdateEncoding| is kinda 472 // the opposite of this, by which 'browser' is notified of 473 // the encoding of the current tab from 'renderer' (determined by 474 // auto-detect, http header, meta, bom detection, etc). 475 virtual void SetOverrideEncoding(const std::string& encoding) = 0; 476 477 // Remove any user-defined override encoding and reload by sending down 478 // ViewMsg_ResetPageEncodingToDefault to the renderer. 479 virtual void ResetOverrideEncoding() = 0; 480 481 // Returns the settings which get passed to the renderer. 482 virtual content::RendererPreferences* GetMutableRendererPrefs() = 0; 483 484 // Tells the tab to close now. The tab will take care not to close until it's 485 // out of nested message loops. 486 virtual void Close() = 0; 487 488 // A render view-originated drag has ended. Informs the render view host and 489 // WebContentsDelegate. 490 virtual void SystemDragEnded() = 0; 491 492 // Notification the user has made a gesture while focus was on the 493 // page. This is used to avoid uninitiated user downloads (aka carpet 494 // bombing), see DownloadRequestLimiter for details. 495 virtual void UserGestureDone() = 0; 496 497 // Indicates if this tab was explicitly closed by the user (control-w, close 498 // tab menu item...). This is false for actions that indirectly close the tab, 499 // such as closing the window. The setter is maintained by TabStripModel, and 500 // the getter only useful from within TAB_CLOSED notification 501 virtual void SetClosedByUserGesture(bool value) = 0; 502 virtual bool GetClosedByUserGesture() const = 0; 503 504 // Opens view-source tab for this contents. 505 virtual void ViewSource() = 0; 506 507 virtual void ViewFrameSource(const GURL& url, 508 const PageState& page_state)= 0; 509 510 // Gets the minimum/maximum zoom percent. 511 virtual int GetMinimumZoomPercent() const = 0; 512 virtual int GetMaximumZoomPercent() const = 0; 513 514 // Gets the preferred size of the contents. 515 virtual gfx::Size GetPreferredSize() const = 0; 516 517 // Called when the reponse to a pending mouse lock request has arrived. 518 // Returns true if |allowed| is true and the mouse has been successfully 519 // locked. 520 virtual bool GotResponseToLockMouseRequest(bool allowed) = 0; 521 522 // Called when the user has selected a color in the color chooser. 523 virtual void DidChooseColorInColorChooser(SkColor color) = 0; 524 525 // Called when the color chooser has ended. 526 virtual void DidEndColorChooser() = 0; 527 528 // Returns true if the location bar should be focused by default rather than 529 // the page contents. The view calls this function when the tab is focused 530 // to see what it should do. 531 virtual bool FocusLocationBarByDefault() = 0; 532 533 // Does this have an opener associated with it? 534 virtual bool HasOpener() const = 0; 535 536 typedef base::Callback<void( 537 int, /* id */ 538 int, /* HTTP status code */ 539 const GURL&, /* image_url */ 540 const std::vector<SkBitmap>&, /* bitmaps */ 541 /* The sizes in pixel of the bitmaps before they were resized due to the 542 max bitmap size passed to DownloadImage(). Each entry in the bitmaps 543 vector corresponds to an entry in the sizes vector. If a bitmap was 544 resized, there should be a single returned bitmap. */ 545 const std::vector<gfx::Size>&)> 546 ImageDownloadCallback; 547 548 // Sends a request to download the given image |url| and returns the unique 549 // id of the download request. When the download is finished, |callback| will 550 // be called with the bitmaps received from the renderer. If |is_favicon| is 551 // true, the cookies are not sent and not accepted during download. 552 // Bitmaps with pixel sizes larger than |max_bitmap_size| are filtered out 553 // from the bitmap results. If there are no bitmap results <= 554 // |max_bitmap_size|, the smallest bitmap is resized to |max_bitmap_size| and 555 // is the only result. A |max_bitmap_size| of 0 means unlimited. 556 virtual int DownloadImage(const GURL& url, 557 bool is_favicon, 558 uint32_t max_bitmap_size, 559 const ImageDownloadCallback& callback) = 0; 560 561 // Returns true if the WebContents is responsible for displaying a subframe 562 // in a different process from its parent page. 563 // TODO: this doesn't really belong here. With site isolation, this should be 564 // removed since we can then embed iframes in different processes. 565 virtual bool IsSubframe() const = 0; 566 567 // Finds text on a page. 568 virtual void Find(int request_id, 569 const base::string16& search_text, 570 const blink::WebFindOptions& options) = 0; 571 572 // Notifies the renderer that the user has closed the FindInPage window 573 // (and what action to take regarding the selection). 574 virtual void StopFinding(StopFindAction action) = 0; 575 576 // Requests the renderer to insert CSS into the main frame's document. 577 virtual void InsertCSS(const std::string& css) = 0; 578 579#if defined(OS_ANDROID) 580 CONTENT_EXPORT static WebContents* FromJavaWebContents( 581 jobject jweb_contents_android); 582 virtual base::android::ScopedJavaLocalRef<jobject> GetJavaWebContents() = 0; 583#elif defined(OS_MACOSX) 584 // The web contents view assumes that its view will never be overlapped by 585 // another view (either partially or fully). This allows it to perform 586 // optimizations. If the view is in a view hierarchy where it might be 587 // overlapped by another view, notify the view by calling this with |true|. 588 virtual void SetAllowOverlappingViews(bool overlapping) = 0; 589 590 // Returns true if overlapping views are allowed, false otherwise. 591 virtual bool GetAllowOverlappingViews() = 0; 592 593 // Allowing other views disables optimizations which assume that only a single 594 // WebContents is present. 595 virtual void SetAllowOtherViews(bool allow) = 0; 596 597 // Returns true if other views are allowed, false otherwise. 598 virtual bool GetAllowOtherViews() = 0; 599#endif // OS_ANDROID 600 601 private: 602 // This interface should only be implemented inside content. 603 friend class WebContentsImpl; 604 WebContents() {} 605}; 606 607} // namespace content 608 609#endif // CONTENT_PUBLIC_BROWSER_WEB_CONTENTS_H_ 610