All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.cef.CefClient Maven / Gradle / Ivy

There is a newer version: 49.87.win64.2
Show newest version
// Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.

package org.cef;

import java.awt.Component;
import java.awt.Container;
import java.awt.FocusTraversalPolicy;
import java.awt.KeyboardFocusManager;
import java.awt.Point;
import java.awt.Rectangle;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.HashMap;
import java.util.Vector;

import javax.swing.SwingUtilities;

import org.cef.browser.CefBrowser;
import org.cef.browser.CefBrowserFactory;
import org.cef.browser.CefMessageRouter;
import org.cef.browser.CefRequestContext;
import org.cef.callback.CefAuthCallback;
import org.cef.callback.CefBeforeDownloadCallback;
import org.cef.callback.CefContextMenuParams;
import org.cef.callback.CefDownloadItem;
import org.cef.callback.CefDownloadItemCallback;
import org.cef.callback.CefDragData;
import org.cef.callback.CefFileDialogCallback;
import org.cef.callback.CefGeolocationCallback;
import org.cef.callback.CefJSDialogCallback;
import org.cef.callback.CefMenuModel;
import org.cef.callback.CefRequestCallback;
import org.cef.handler.CefClientHandler;
import org.cef.handler.CefContextMenuHandler;
import org.cef.handler.CefDialogHandler;
import org.cef.handler.CefDisplayHandler;
import org.cef.handler.CefDownloadHandler;
import org.cef.handler.CefDragHandler;
import org.cef.handler.CefFocusHandler;
import org.cef.handler.CefGeolocationHandler;
import org.cef.handler.CefJSDialogHandler;
import org.cef.handler.CefKeyboardHandler;
import org.cef.handler.CefLifeSpanHandler;
import org.cef.handler.CefLoadHandler;
import org.cef.handler.CefRenderHandler;
import org.cef.handler.CefRequestHandler;
import org.cef.handler.CefResourceHandler;
import org.cef.handler.CefWindowHandler;
import org.cef.misc.BoolRef;
import org.cef.misc.StringRef;
import org.cef.network.CefRequest;
import org.cef.network.CefWebPluginInfo;

/**
 * Client that owns a browser and renderer.
 */
public class CefClient extends CefClientHandler implements CefContextMenuHandler,
                                                           CefDialogHandler,
                                                           CefDisplayHandler,
                                                           CefDownloadHandler,
                                                           CefDragHandler,
                                                           CefFocusHandler,
                                                           CefGeolocationHandler,
                                                           CefJSDialogHandler,
                                                           CefKeyboardHandler,
                                                           CefLifeSpanHandler,
                                                           CefLoadHandler,
                                                           CefRenderHandler,
                                                           CefRequestHandler,
                                                           CefWindowHandler {
  private HashMap browser_ = new HashMap();
  private CefContextMenuHandler contextMenuHandler_ = null;
  private CefDialogHandler dialogHandler_ = null;
  private CefDisplayHandler displayHandler_ = null;
  private CefDownloadHandler downloadHandler_ = null;
  private CefDragHandler dragHandler_ = null;
  private CefFocusHandler focusHandler_ = null;
  private CefGeolocationHandler geolocationHandler_ = null;
  private CefJSDialogHandler jsDialogHandler_ = null;
  private CefKeyboardHandler keyboardHandler_ = null;
  private CefLifeSpanHandler lifeSpanHandler_ = null;
  private CefLoadHandler loadHandler_ = null;
  private CefRequestHandler requestHandler_ = null;
  private boolean wasDisposed = false;
  private volatile CefBrowser focusedBrowser_ = null;

  /**
   * The CTOR is only accessible within this package.
   * Use CefApp.createClient() to create an instance of
   * this class.
   * @see org.cef.CefApp.createClient()
   */
  CefClient() throws UnsatisfiedLinkError {
    super();

    KeyboardFocusManager km = 
        KeyboardFocusManager.getCurrentKeyboardFocusManager();
    km.addPropertyChangeListener(new PropertyChangeListener() {
      @Override
      public void propertyChange(PropertyChangeEvent evt) {
        if (focusedBrowser_ != null) {
          Component browserUI = focusedBrowser_.getUIComponent();
          Object oldUI = evt.getOldValue();
          if (isPartOf(oldUI, browserUI)) {
            focusedBrowser_.setFocus(false);
            focusedBrowser_ = null;
          }
        }
      }
    });
  }
  
  private boolean isPartOf(Object obj, Component browserUI) {
    if  (obj == browserUI)
      return true;
    if (obj instanceof Container) {
      Component childs[] = ((Container)obj).getComponents();
      for (Component child : childs) {
        return isPartOf(child, browserUI);
      }
    }
    return false;
  }

  @Override
  public void dispose() {
    wasDisposed = true;
    synchronized (browser_) {
      if(browser_.isEmpty()) {
          CefApp.getInstance().clientWasDisposed(this);
      } else {
        final HashMap clone = new HashMap<>(browser_);
        Collection browserList = clone.values();
        for (CefBrowser browser : browserList) {
              onBeforeClose(browser);
            browser.close();
          }
      }
    }
  }


  // CefClientHandler

  public CefBrowser createBrowser(String url,
                                  boolean isOffscreenRendered,
                                  boolean isTransparent) {
    return createBrowser(url, isOffscreenRendered, isTransparent, null);
  }

  public CefBrowser createBrowser(String url,
                                  boolean isOffscreenRendered,
                                  boolean isTransparent,
                                  CefRequestContext context) {
	if (wasDisposed) {
	  throw new IllegalStateException("Can't create browser. CefClient is disposed");
	} else {
	  final CefBrowser browser = CefBrowserFactory.create(this, url, isOffscreenRendered, isTransparent, context);
	  onAfterCreated(browser);
	  return browser;
	}
  }

  @Override
  protected CefBrowser getBrowser(int identifier) {
    synchronized (browser_) {
      return browser_.get(new Integer(identifier));
    }
  }

  @Override
  protected Object[] getAllBrowser() {
    synchronized (browser_) {
      return browser_.values().toArray();
    }
  }

  @Override
  protected CefContextMenuHandler getContextMenuHandler() {
    return this;
  }

  @Override 
  protected CefDialogHandler getDialogHandler() {
    return this;
  };

  @Override
  protected CefDisplayHandler getDisplayHandler() {
    return this;
  }

  @Override
  protected CefDownloadHandler getDownloadHandler() {
    return this;
  }

  @Override
  protected CefDragHandler getDragHandler() {
    return this;
  }

  @Override
  protected CefFocusHandler getFocusHandler() {
    return this;
  }

  @Override
  protected CefGeolocationHandler getGeolocationHandler() {
    return this;
  }

  @Override
  protected CefJSDialogHandler getJSDialogHandler() {
    return this;
  }

  @Override
  protected CefKeyboardHandler getKeyboardHandler() {
    return this;
  }

  @Override
  protected CefLifeSpanHandler getLifeSpanHandler() {
    return this;
  }

  @Override
  protected CefLoadHandler getLoadHandler() {
    return this;
  }

  @Override
  protected CefRenderHandler getRenderHandler() {
    return this;
  }

  @Override
  protected CefRequestHandler getRequestHandler() {
    return this;
  }

  @Override
  protected CefWindowHandler getWindowHandler() {
    return this;
  }

  // CefContextMenuHandler

  public CefClient addContextMenuHandler(CefContextMenuHandler handler) {
    if (contextMenuHandler_ == null)
      contextMenuHandler_ = handler;
    return this;
  }

  public void removeContextMenuHandler() {
    contextMenuHandler_ = null;
  }

  @Override
  public void onBeforeContextMenu(CefBrowser browser,
                                  CefContextMenuParams params,
                                  CefMenuModel model) {
    if (contextMenuHandler_ != null && browser != null)
      contextMenuHandler_.onBeforeContextMenu(browser, params, model);
  }

  @Override
  public boolean onContextMenuCommand(CefBrowser browser,
                                      CefContextMenuParams params,
                                      int commandId,
                                      int eventFlags) {
    if (contextMenuHandler_ != null && browser != null)
      return contextMenuHandler_.onContextMenuCommand(browser, params, commandId, eventFlags);
    return false;
  }

  @Override
  public void onContextMenuDismissed(CefBrowser browser) {
    if (contextMenuHandler_ != null && browser != null)
      contextMenuHandler_.onContextMenuDismissed(browser);
  }


  // CefDialogHandler

  public CefClient addDialogHandler(CefDialogHandler handler) {
    if (dialogHandler_ == null)
      dialogHandler_ = handler;
    return this;
  }

  public void removeDialogHandler() {
    dialogHandler_ = null;
  }

  @Override
  public boolean onFileDialog(CefBrowser browser,
                              FileDialogMode mode,
                              String title,
                              String defaultFilePath,
                              Vector acceptFilters,
                              int selectedAcceptFilter,
                              CefFileDialogCallback callback) {
    if (dialogHandler_ != null && browser != null) {
      return dialogHandler_.onFileDialog(browser, mode, title, defaultFilePath,
                                         acceptFilters, selectedAcceptFilter, callback);
    }
    return false;
  }


  // CefDisplayHandler

  public CefClient addDisplayHandler(CefDisplayHandler handler) {
    if (displayHandler_ == null)
      displayHandler_ = handler;
    return this;
  }

  public void removeDisplayHandler() {
    displayHandler_ = null;
  }

  @Override
  public void onAddressChange(CefBrowser browser, String url) {
    if (displayHandler_ != null && browser != null)
      displayHandler_.onAddressChange(browser, url);
  }

  @Override
  public void onTitleChange(CefBrowser browser, String title) {
    if (displayHandler_ != null && browser != null)
      displayHandler_.onTitleChange(browser, title);
  }

  @Override
  public boolean onTooltip(CefBrowser browser, String text) {
    if (displayHandler_ != null && browser != null) {
      return displayHandler_.onTooltip(browser, text);
    }
    return false;
  }

  @Override
  public void onStatusMessage(CefBrowser browser, String value) {
    if (displayHandler_ != null && browser != null) {
      displayHandler_.onStatusMessage(browser, value);
    }
  }

  @Override
  public boolean onConsoleMessage(CefBrowser browser,
                                  String message,
                                  String source,
                                  int line) {
    if (displayHandler_ != null && browser != null) {
      return displayHandler_.onConsoleMessage(browser, message, source, line);
    }
    return false;
  }


  // CefDownloadHandler

  public CefClient addDownloadHandler(CefDownloadHandler handler) {
    if (downloadHandler_ == null)
      downloadHandler_ = handler;
    return this;
  }

  public void removeDownloadHandler() {
    downloadHandler_ = null;
  }

  @Override
  public void onBeforeDownload(CefBrowser browser,
                               CefDownloadItem downloadItem,
                               String suggestedName,
                               CefBeforeDownloadCallback callback) {
    if (downloadHandler_ != null && browser != null)
      downloadHandler_.onBeforeDownload(browser, downloadItem, suggestedName, callback);
  }

  @Override
  public void onDownloadUpdated(CefBrowser browser,
                                CefDownloadItem downloadItem,
                                CefDownloadItemCallback callback) {
    if (downloadHandler_ != null && browser != null)
      downloadHandler_.onDownloadUpdated(browser, downloadItem, callback);
  }


  // CefDragHandler

  public CefClient addDragHandler(CefDragHandler handler) {
    if (dragHandler_ == null)
      dragHandler_ = handler;
    return this;
  }

  public void removeDragHandler() {
    dragHandler_ = null;
  }

  @Override
  public boolean onDragEnter(CefBrowser browser, CefDragData dragData, int mask) {
    if (dragHandler_ != null && browser != null)
      return dragHandler_.onDragEnter(browser, dragData, mask);
    return false;
  }


  // CefFocusHandler

  public CefClient addFocusHandler(CefFocusHandler handler) {
    if (focusHandler_ == null)
      focusHandler_ = handler;
    return this;
  }

  public void removeFocusHandler() {
    focusHandler_ = null;
  }

  @Override
  public void onTakeFocus(CefBrowser browser, boolean next) {
    if (browser == null)
      return;

    browser.setFocus(false);
    Container parent = browser.getUIComponent().getParent();
    if (parent != null) {
      FocusTraversalPolicy policy = null;
      while (parent != null) {
        policy = parent.getFocusTraversalPolicy();
        if (policy != null)
          break;
        parent = parent.getParent();
      }
      if (policy != null) {
        Component nextComp = next ? policy.getComponentAfter(parent, browser.getUIComponent())
                                  : policy.getComponentBefore(parent, browser.getUIComponent());
        if (nextComp == null) {
          policy.getDefaultComponent(parent).requestFocus();
        } else {
          nextComp.requestFocus();
        }
      }
    }
    focusedBrowser_ = null;
    if (focusHandler_ != null)
      focusHandler_.onTakeFocus(browser, next);
  }

  @Override
  public boolean onSetFocus(final CefBrowser browser, FocusSource source) {
    if (browser == null)
      return false;

    boolean alreadyHandled = false;
    if (focusHandler_ != null)
      alreadyHandled = focusHandler_.onSetFocus(browser, source);
    if (!alreadyHandled) {
      Runnable r = new Runnable() {
        @Override
        public void run() {
          browser.getUIComponent().requestFocus();
        }
      };
      if (SwingUtilities.isEventDispatchThread())
        r.run();
      else
        SwingUtilities.invokeLater(r);
    }
    return alreadyHandled;
  }

  @Override
  public void onGotFocus(CefBrowser browser) {
    if (browser == null)
      return;

    focusedBrowser_ = browser;
    browser.setFocus(true);
    if (focusHandler_ != null)
      focusHandler_.onGotFocus(browser);
  }


  // CefGeolocationHandler

  public CefClient addGeolocationHandler(CefGeolocationHandler handler) {
    if (geolocationHandler_ == null)
      geolocationHandler_ = handler;
    return this;
  }

  public void removeGeolocationHandler() {
    geolocationHandler_ = null;
  }

  @Override
  public boolean onRequestGeolocationPermission(
      CefBrowser browser,
      String requesting_url,
      int request_id,
      CefGeolocationCallback callback) {
    if (geolocationHandler_ != null && browser != null) {
      return geolocationHandler_.onRequestGeolocationPermission(browser,
          requesting_url, request_id, callback);
    }
    return false;
  }

  @Override
  public void onCancelGeolocationPermission(CefBrowser browser,
                                            int request_id) {
    if (geolocationHandler_ != null && browser != null)
      geolocationHandler_.onCancelGeolocationPermission(browser, request_id);
  }


  // CefJSDialogHandler

  public CefClient addJSDialogHandler(CefJSDialogHandler handler) {
    if (jsDialogHandler_ == null)
      jsDialogHandler_ = handler;
    return this;
  }

  public void removeJSDialogHandler() {
    jsDialogHandler_ = null;
  }

  @Override
  public boolean onJSDialog(CefBrowser browser,
                            String origin_url,
                            String accept_lang,
                            JSDialogType dialog_type,
                            String message_text,
                            String default_prompt_text,
                            CefJSDialogCallback callback,
                            BoolRef suppress_message) {
    if (jsDialogHandler_ != null && browser != null)
      return jsDialogHandler_.onJSDialog(browser,
                                         origin_url,
                                         accept_lang,
                                         dialog_type,
                                         message_text,
                                         default_prompt_text,
                                         callback,
                                         suppress_message);
    return false;
  }

  @Override
  public boolean onBeforeUnloadDialog(CefBrowser browser,
                                      String message_text,
                                      boolean is_reload,
                                      CefJSDialogCallback callback) {
    if (jsDialogHandler_ != null && browser != null)
      return jsDialogHandler_.onBeforeUnloadDialog(browser, message_text, is_reload, callback);
    return false;
  }

  @Override
  public void onResetDialogState(CefBrowser browser) {
    if (jsDialogHandler_ != null && browser != null)
      jsDialogHandler_.onResetDialogState(browser);
  }

  @Override
  public void onDialogClosed(CefBrowser browser) {
    if (jsDialogHandler_ != null && browser != null)
      jsDialogHandler_.onDialogClosed(browser);
  }


  // CefKeyboardHandler

  public CefClient addKeyboardHandler(CefKeyboardHandler handler) {
    if (keyboardHandler_ == null)
      keyboardHandler_ = handler;
    return this;
  }

  public void removeKeyboardHandler() {
    keyboardHandler_ = null;
  }

  @Override
  public boolean onPreKeyEvent(CefBrowser browser,
                               CefKeyEvent event,
                               BoolRef is_keyboard_shortcut) {
    if (keyboardHandler_ != null && browser != null)
      return keyboardHandler_.onPreKeyEvent(browser, event, is_keyboard_shortcut);
    return false;
  }

  @Override
  public boolean onKeyEvent(CefBrowser browser, CefKeyEvent event) {
    if (keyboardHandler_ != null && browser != null)
      return keyboardHandler_.onKeyEvent(browser, event);
    return false;
  }


  // CefLifeSpanHandler

  public CefClient addLifeSpanHandler(CefLifeSpanHandler handler) {
    if (lifeSpanHandler_ == null)
      lifeSpanHandler_ = handler;
    return this;
  }

  public void removeLifeSpanHandler() {
    lifeSpanHandler_ = null;
  }

  @Override
  public boolean onBeforePopup(CefBrowser browser,
                               String target_url,
                               String target_frame_name) {
    if (wasDisposed)
      return true;
    if (lifeSpanHandler_ != null && browser != null)
      return lifeSpanHandler_.onBeforePopup(browser,
                                            target_url,
                                            target_frame_name);
    return false;
  }

  @Override
  public void onAfterCreated(CefBrowser browser) {
    if (browser == null)
      return;

    // keep browser reference
    Integer identifier = browser.getIdentifier();
    synchronized (browser_) {
      browser_.put(identifier, browser);
    }
    if (lifeSpanHandler_ != null)
      lifeSpanHandler_.onAfterCreated(browser);
  }

  @Override
  public boolean runModal(CefBrowser browser) {
    if (lifeSpanHandler_ != null && browser != null)
      return lifeSpanHandler_.runModal(browser);
    return false;
  }

  @Override
  public boolean doClose(CefBrowser browser) {
    if (lifeSpanHandler_ != null && browser != null)
      return lifeSpanHandler_.doClose(browser);
    return false;
  }

  @Override
  public void onBeforeClose(CefBrowser browser) {
    if (browser == null)
      return;

    if (lifeSpanHandler_ != null)
      lifeSpanHandler_.onBeforeClose(browser);

    // remove browser reference
    int identifier = browser.getIdentifier();

    synchronized (browser_) {
      browser_.remove(identifier);
      if (browser_.isEmpty() && wasDisposed) {
        removeContextMenuHandler(this);
        removeDialogHandler(this);
        removeDisplayHandler(this);
        removeDownloadHandler(this);
        removeDragHandler(this);
        removeFocusHandler(this);
        removeGeolocationHandler(this);
        removeJSDialogHandler(this);
        removeKeyboardHandler(this);
        removeLifeSpanHandler(this);
        removeLoadHandler(this);
        removeRenderHandler(this);
        removeRequestHandler(this);
        removeWindowHandler(this);
        super.dispose();

        CefApp.getInstance().clientWasDisposed(this);
      }
    }
  }


  // CefLoadHandler

  public CefClient addLoadHandler(CefLoadHandler handler) {
    if (loadHandler_ == null)
      loadHandler_ = handler;
    return this;
  }

  public void removeLoadHandler() {
    loadHandler_ = null;
  }

  @Override
  public void onLoadingStateChange(CefBrowser browser,
                                   boolean isLoading,
                                   boolean canGoBack,
                                   boolean canGoForward) {
    if (loadHandler_ != null && browser != null)
      loadHandler_.onLoadingStateChange(browser, isLoading, canGoBack, canGoForward);
  }

  @Override
  public void onLoadStart(CefBrowser browser, int frameIdentifer) {
    if (loadHandler_ != null && browser != null)
      loadHandler_.onLoadStart(browser, frameIdentifer);
  }

  @Override
  public void onLoadEnd(CefBrowser browser,
                        int frameIdentifier,
                        int httpStatusCode) {
    if (loadHandler_ != null && browser != null)
      loadHandler_.onLoadEnd(browser, frameIdentifier, httpStatusCode);
  }

  @Override
  public void onLoadError(CefBrowser browser,
                          int frameIdentifer,
                          ErrorCode errorCode,
                          String errorText,
                          String failedUrl) {
    if (loadHandler_ != null && browser != null)
      loadHandler_.onLoadError(browser, frameIdentifer, errorCode, errorText, failedUrl);
  }



  // CefMessageRouter

  @Override
  public synchronized void addMessageRouter(CefMessageRouter messageRouter) {
    super.addMessageRouter(messageRouter);
  }

  @Override
  public synchronized void removeMessageRouter(CefMessageRouter messageRouter) {
    super.removeMessageRouter(messageRouter);
  }


  // CefRenderHandler

  @Override
  public Rectangle getViewRect(CefBrowser browser) {
    if (browser == null)
      return new Rectangle(0,0,0,0);

    CefRenderHandler realHandler = browser.getRenderHandler();
    if (realHandler != null)
      return realHandler.getViewRect(browser);
    return new Rectangle(0,0,0,0);
  }

  @Override
  public Point getScreenPoint(CefBrowser browser, Point viewPoint) {
    if (browser == null)
      return new Point(0,0);

    CefRenderHandler realHandler = browser.getRenderHandler();
    if (realHandler != null)
      return realHandler.getScreenPoint(browser,viewPoint);
    return new Point(0,0);
  }

  @Override
  public void onPopupShow(CefBrowser browser,
                          boolean show) {
    if (browser == null)
      return;

    CefRenderHandler realHandler = browser.getRenderHandler();
    if (realHandler != null)
      realHandler.onPopupShow(browser, show);
  }

  @Override
  public void onPopupSize(CefBrowser browser,
                          Rectangle size) {
    if (browser == null)
      return;

    CefRenderHandler realHandler = browser.getRenderHandler();
    if (realHandler != null)
      realHandler.onPopupSize(browser, size);
  }

  @Override
  public void onPaint(CefBrowser browser,
                      boolean popup,
                      Rectangle[] dirtyRects,
                      ByteBuffer buffer,
                      int width,
                      int height) {
    if (browser == null)
      return;

    CefRenderHandler realHandler = browser.getRenderHandler();
    if (realHandler != null)
      realHandler.onPaint(browser, popup, dirtyRects, buffer, width, height);
  }

  @Override
  public void onCursorChange(CefBrowser browser,
                             int cursorType) {
    if (browser == null)
      return;

    CefRenderHandler realHandler = browser.getRenderHandler();
    if (realHandler != null)
      realHandler.onCursorChange(browser, cursorType);
  }

  @Override
  public boolean startDragging(CefBrowser browser,
                               CefDragData dragData,
                               int mask,
                               int x,
                               int y) {
    if (browser == null)
      return false;

    CefRenderHandler realHandler = browser.getRenderHandler();
    if (realHandler != null)
      return realHandler.startDragging(browser, dragData, mask, x, y);
    return false;
  }

  @Override
  public void updateDragCursor(CefBrowser browser,
                               int operation) {
    if (browser == null)
      return;

    CefRenderHandler realHandler = browser.getRenderHandler();
    if (realHandler != null)
      realHandler.updateDragCursor(browser, operation);
  }


  // CefRequestHandler

  public CefClient addRequestHandler(CefRequestHandler handler) {
    if (requestHandler_ == null)
      requestHandler_ = handler;
    return this;
  }

  public void removeRequestHandler() {
    requestHandler_ = null;
  }

  @Override
  public boolean onBeforeBrowse(CefBrowser browser,
                                CefRequest request,
                                boolean is_redirect) {
    if (requestHandler_ != null && browser != null)
      return requestHandler_.onBeforeBrowse(browser, request, is_redirect);
    return false;
  }

  @Override
  public boolean onBeforeResourceLoad(CefBrowser browser, CefRequest request) {
    if (requestHandler_ != null && browser != null)
      return requestHandler_.onBeforeResourceLoad(browser, request);
    return false;
  }

  @Override
  public CefResourceHandler getResourceHandler(CefBrowser browser,
                                               CefRequest request) {
    if (requestHandler_ != null && browser != null)
      return requestHandler_.getResourceHandler(browser, request);
    return null;
  }

  @Override
  public void onResourceRedirect(CefBrowser browser,
                                 CefRequest request,
                                 StringRef new_url) {
    if (requestHandler_ != null && browser != null)
      requestHandler_.onResourceRedirect(browser, request, new_url);
  }

  @Override
  public boolean getAuthCredentials(CefBrowser browser,
                                    boolean isProxy,
                                    String host,
                                    int port,
                                    String realm,
                                    String scheme,
                                    CefAuthCallback callback) {
    if (requestHandler_ != null && browser != null)
      return requestHandler_.getAuthCredentials(browser, isProxy, host, port, realm, scheme, callback);
    return false;
  }

  @Override
  public boolean onQuotaRequest(CefBrowser browser,
                                String origin_url,
                                long new_size,
                                CefRequestCallback callback) {
    if (requestHandler_ != null && browser != null)
      return requestHandler_.onQuotaRequest(browser, origin_url, new_size, callback);
    return false;
  }

  @Override
  public void onProtocolExecution(CefBrowser browser,
                                  String url,
                                  BoolRef allow_os_execution) {
    if (requestHandler_ != null && browser != null)
      requestHandler_.onProtocolExecution(browser, url, allow_os_execution);
  }

  @Override
  public boolean onCertificateError(CefBrowser browser,
                                    ErrorCode cert_error,
                                    String request_url,
                                    CefRequestCallback callback) {
    if (requestHandler_ != null)
      return requestHandler_.onCertificateError(browser, cert_error, request_url, callback);
    return false;
  }

  @Override
  public void onPluginCrashed(CefBrowser browser,
                              String pluginPath) {
    if (requestHandler_ != null)
      requestHandler_.onPluginCrashed(browser, pluginPath);
  }

  @Override
  public void onRenderProcessTerminated(CefBrowser browser,
                                        TerminationStatus status) {
    if (requestHandler_ != null)
      requestHandler_.onRenderProcessTerminated(browser, status);
  }


  // CefWindowHandler

  @Override
  public Rectangle getRect(CefBrowser browser) {
    if (browser == null)
      return new Rectangle(0,0,0,0);

    CefWindowHandler realHandler = browser.getWindowHandler();
    if (realHandler != null)
      return realHandler.getRect(browser);
    return new Rectangle(0,0,0,0);
  }

  @Override
  public void onMouseEvent(CefBrowser browser, int event, int screenX,
      int screenY, int modifier, int button) {
    if (browser == null)
      return;

    CefWindowHandler realHandler = browser.getWindowHandler();
    if (realHandler != null)
      realHandler.onMouseEvent(browser, event, screenX, screenY, modifier,
          button);
  }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy