gui_handler.cxx

Go to the documentation of this file.

/// \file gui_handler.cxx
// Author: Sergey Linev <S.Linev@gsi.de>
// Date: 2017-06-29
// Warning: This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback is welcome!
 
/*************************************************************************
 * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#if !defined(_MSC_VER)
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wshadow"
#endif
 
#include "gui_handler.h"
#include "simple_app.h"
 
#include <sstream>
#include <fstream>
#include <iostream>
#include <string>
 
#include "include/base/cef_bind.h"
#include "include/cef_app.h"
#include "include/cef_version.h"
#include "include/views/cef_browser_view.h"
#include "include/views/cef_window.h"
#include "include/wrapper/cef_closure_task.h"
#include "include/wrapper/cef_helpers.h"
#include "include/cef_parser.h"
#include "include/wrapper/cef_stream_resource_handler.h"
 
#include "TEnv.h"
#include "TUrl.h"
#include "THttpServer.h"
#include "THttpCallArg.h"
#include "TSystem.h"
#include "TBase64.h"
#include <ROOT/RLogger.hxx>
 
ROOT::RLogChannel &CefWebDisplayLog()
{
   static ROOT::RLogChannel sChannel("ROOT.CefWebDisplay");
   return sChannel;
}
 
 
GuiHandler::GuiHandler(bool use_views) : fUseViews(use_views), is_closing_(false)
{
   fConsole = gEnv->GetValue("WebGui.Console", (int)0);
 
   // see https://bitbucket.org/chromiumembedded/cef-project/src/master/examples/resource_manager/?at=master for demo
   // one probably can avoid to use scheme handler and just redirect requests
   fResourceManager = new CefResourceManager();
}
 
void GuiHandler::OnTitleChange(CefRefPtr<CefBrowser> browser, const CefString &title)
{
   CEF_REQUIRE_UI_THREAD();
 
   if (fUseViews) {
      // Set the title of the window using the Views framework.
      CefRefPtr<CefBrowserView> browser_view = CefBrowserView::GetForBrowser(browser);
      if (browser_view) {
         CefRefPtr<CefWindow> window = browser_view->GetWindow();
         if (window) window->SetTitle(title);
      }
   } else {
      // Set the title of the window using platform APIs.
      PlatformTitleChange(browser, title);
   }
}
 
void GuiHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser)
{
   CEF_REQUIRE_UI_THREAD();
 
   // Add to the list of existing browsers.
   fBrowserList.emplace_back(browser);
}
 
bool GuiHandler::DoClose(CefRefPtr<CefBrowser> browser)
{
   CEF_REQUIRE_UI_THREAD();
 
   // Closing the main window requires special handling. See the DoClose()
   // documentation in the CEF header for a detailed description of this
   // process.
   if (fBrowserList.size() == 1) {
      // Set a flag to indicate that the window close should be allowed.
      is_closing_ = true;
   }
 
   // Allow the close. For windowed browsers this will result in the OS close
   // event being sent.
   return false;
}
 
void GuiHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser)
{
   CEF_REQUIRE_UI_THREAD();
 
   // Remove from the list of existing browsers.
   auto bit = fBrowserList.begin();
   for (; bit != fBrowserList.end(); ++bit) {
      if ((*bit)->IsSame(browser)) {
         fBrowserList.erase(bit);
         break;
      }
   }
 
   if (fBrowserList.empty()) {
 
      // All browser windows have closed. Quit the application message loop.
 
      CefQuitMessageLoop();
   }
}
 
// Returns a data: URI with the specified contents.
std::string GuiHandler::GetDataURI(const std::string& data, const std::string& mime_type)
{
    return std::string("data:") + mime_type + ";base64," +
           CefURIEncode(CefBase64Encode(data.data(), data.size()), false).ToString();
}
 
 
void GuiHandler::OnLoadError(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, ErrorCode errorCode,
                              const CefString &errorText, const CefString &failedUrl)
{
   CEF_REQUIRE_UI_THREAD();
 
   // Don't display an error for downloaded files.
   if (errorCode == ERR_ABORTED)
      return;
 
   // Display a load error message.
   /*
   std::stringstream ss;
   ss << "<html><body bgcolor=\"white\">"
         "<h2>Failed to load URL "
      << failedUrl.ToString().substr(0,100) << " with error " << errorText.ToString() << " (" << errorCode
      << ").</h2></body></html>";
   frame->LoadURL(GetDataURI(ss.str(), "text/html"));
   */
 
   printf("Fail to load URL %s\n", failedUrl.ToString().substr(0,100).c_str());
}
 
void GuiHandler::CloseAllBrowsers(bool force_close)
{
   if (!CefCurrentlyOn(TID_UI)) {
      // Execute on the UI thread.
      CefPostTask(TID_UI, base::BindOnce(&GuiHandler::CloseAllBrowsers, this, force_close));
      return;
   }
 
   if (fBrowserList.empty())
      return;
 
   for (auto &br : fBrowserList)
      br->GetHost()->CloseBrowser(force_close);
}
 
bool GuiHandler::OnConsoleMessage(CefRefPtr<CefBrowser> browser,
                                  cef_log_severity_t level,
                                  const CefString &message, const CefString &source,
                                  int line)
{
   std::string src = source.ToString().substr(0,100);
 
   switch (level) {
   case LOGSEVERITY_WARNING:
      if (fConsole > -1)
         std::cout << TString::Format("CEF: %s:%d: %s", src.c_str(), line, message.ToString().c_str()) << std::endl;
      break;
   case LOGSEVERITY_ERROR:
      if (fConsole > -2)
         std::cerr << TString::Format("CEF: %s:%d: %s", src.c_str(), line, message.ToString().c_str()) << std::endl;
      break;
   default:
      if (fConsole > 0)
         std::cout << TString::Format("CEF: %s:%d: %s", src.c_str(), line, message.ToString().c_str()) << std::endl;
      break;
   }
 
   return true;
}
 
 
cef_return_value_t GuiHandler::OnBeforeResourceLoad(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefFrame> frame,
    CefRefPtr<CefRequest> request,
    CefRefPtr<CefCallback> callback) {
  CEF_REQUIRE_IO_THREAD();
 
  return fResourceManager->OnBeforeResourceLoad(browser, frame, request,
                                                 callback);
}
 
 
class TCefHttpCallArg : public THttpCallArg {
protected:
 
   CefRefPtr<CefCallback> fCallBack{nullptr};
 
public:
   explicit TCefHttpCallArg() = default;
 
   /** provide WS kind  */
   const char *GetWSKind() const override { return "longpoll"; }
 
   /** provide WS platform */
   const char *GetWSPlatform() const override { return "cef3"; }
 
   void AssignCallback(CefRefPtr<CefCallback> cb) { fCallBack = cb; }
 
   // this is callback from HTTP server
   void HttpReplied() override
   {
      if (IsFile()) {
         // send file
         std::string file_content = THttpServer::ReadFileContent((const char *)GetContent());
         SetContent(std::move(file_content));
      }
 
      fCallBack->Continue(); // we have result and can continue with processing
   }
};
 
 
class TGuiResourceHandler : public CefResourceHandler {
public:
   // QWebEngineUrlRequestJob *fRequest;
 
   THttpServer *fServer{nullptr};
   std::shared_ptr<TCefHttpCallArg> fArg;
 
   int fTransferOffset{0};
 
   explicit TGuiResourceHandler(THttpServer *serv, bool dummy = false)
   {
      fServer = serv;
 
      if (!dummy)
         fArg = std::make_shared<TCefHttpCallArg>();
   }
 
   ~TGuiResourceHandler() override {}
 
   void Cancel() override { CEF_REQUIRE_IO_THREAD(); }
 
   bool ProcessRequest(CefRefPtr<CefRequest> request, CefRefPtr<CefCallback> callback) override
   {
      CEF_REQUIRE_IO_THREAD();
 
      if (fArg) {
         fArg->AssignCallback(callback);
         fServer->SubmitHttp(fArg);
      } else {
         callback->Continue();
      }
 
      return true;
   }
#if CEF_VERSION_MAJOR > 114
   void GetResponseHeaders(CefRefPtr<CefResponse> response, int64_t &response_length, CefString &redirectUrl) override
#else
   void GetResponseHeaders(CefRefPtr<CefResponse> response, int64 &response_length, CefString &redirectUrl) override
#endif
   {
      CEF_REQUIRE_IO_THREAD();
 
      if (!fArg || fArg->Is404()) {
         response->SetMimeType("text/html");
         response->SetStatus(404);
         response_length = 0;
      } else {
         response->SetMimeType(fArg->GetContentType());
         response->SetStatus(200);
         response_length = fArg->GetContentLength();
 
         if (fArg->NumHeader() > 0) {
            CefResponse::HeaderMap headers;
            for (Int_t n = 0; n < fArg->NumHeader(); ++n) {
               TString name = fArg->GetHeaderName(n);
               TString value = fArg->GetHeader(name.Data());
               headers.emplace(CefString(name.Data()), CefString(value.Data()));
            }
            response->SetHeaderMap(headers);
         }
      }
      // DCHECK(!fArg->Is404());
   }
 
   bool ReadResponse(void *data_out, int bytes_to_read, int &bytes_read, CefRefPtr<CefCallback> callback) override
   {
      CEF_REQUIRE_IO_THREAD();
 
      if (!fArg) return false;
 
      bytes_read = 0;
 
      if (fTransferOffset < fArg->GetContentLength()) {
         char *data_ = (char *)fArg->GetContent();
         // Copy the next block of data into the buffer.
         int transfer_size = fArg->GetContentLength() - fTransferOffset;
         if (transfer_size > bytes_to_read)
            transfer_size = bytes_to_read;
         memcpy(data_out, data_ + fTransferOffset, transfer_size);
         fTransferOffset += transfer_size;
 
         bytes_read = transfer_size;
      }
 
      // if content fully copied - can release reference, object will be cleaned up
      if (fTransferOffset >= fArg->GetContentLength())
         fArg.reset();
 
      return bytes_read > 0;
   }
 
   IMPLEMENT_REFCOUNTING(TGuiResourceHandler);
   DISALLOW_COPY_AND_ASSIGN(TGuiResourceHandler);
};
 
 
CefRefPtr<CefResourceHandler> GuiHandler::GetResourceHandler(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefFrame> frame,
    CefRefPtr<CefRequest> request) {
  CEF_REQUIRE_IO_THREAD();
 
  std::string addr = request->GetURL().ToString();
  std::string prefix = "http://rootserver.local";
 
  if (addr.compare(0, prefix.length(), prefix) != 0)
     return fResourceManager->GetResourceHandler(browser, frame, request);
 
  int indx = std::stoi(addr.substr(prefix.length(), addr.find("/", prefix.length()) - prefix.length()));
 
  if ((indx < 0) || (indx >= (int) fServers.size()) || !fServers[indx]) {
     R__LOG_ERROR(CefWebDisplayLog()) << "No THttpServer with index " << indx;
     return nullptr;
  }
 
  THttpServer *serv = fServers[indx];
  if (serv->IsZombie()) {
     fServers[indx] = nullptr;
     R__LOG_ERROR(CefWebDisplayLog()) << "THttpServer with index " << indx << " is zombie now";
     return nullptr;
  }
 
  TUrl url(addr.c_str());
 
  const char *inp_path = url.GetFile();
 
  TString inp_query = url.GetOptions();
 
  TString fname;
 
  if (serv->IsFileRequested(inp_path, fname)) {
     // process file - no need for special requests handling
 
     std::ifstream ifs(fname.Data());
     // when file not exists - return default handler otherwise CEF terminates
     if (!ifs)
        return new TGuiResourceHandler(serv, true);
 
     const char *mime = THttpServer::GetMimeType(fname.Data());
 
     CefRefPtr<CefStreamReader> stream = CefStreamReader::CreateForFile(fname.Data());
 
     // Constructor for HTTP status code 200 and no custom response headers.
     // There’s also a version of the constructor for custom status code and response headers.
     return new CefStreamResourceHandler(mime, stream);
  }
 
  std::string inp_method = request->GetMethod().ToString();
 
  TGuiResourceHandler *handler = new TGuiResourceHandler(serv);
  handler->fArg->SetMethod(inp_method.c_str());
  handler->fArg->SetPathAndFileName(inp_path);
  handler->fArg->SetTopName("webgui");
 
  if (inp_method == "POST") {
 
     CefRefPtr< CefPostData > post_data = request->GetPostData();
 
     if (!post_data) {
        R__LOG_ERROR(CefWebDisplayLog()) << "FATAL - NO POST DATA in CEF HANDLER!!!";
        exit(1);
     } else {
        CefPostData::ElementVector elements;
        post_data->GetElements(elements);
        size_t sz = 0, off = 0;
        for (unsigned n = 0; n < elements.size(); ++n)
           sz += elements[n]->GetBytesCount();
        std::string data;
        data.resize(sz);
 
        for (unsigned n = 0; n < elements.size(); ++n) {
           sz = elements[n]->GetBytes(elements[n]->GetBytesCount(), (char *)data.data() + off);
           off += sz;
        }
        handler->fArg->SetPostData(std::move(data));
     }
  } else if (inp_query.Index("&post=") != kNPOS) {
     Int_t pos = inp_query.Index("&post=");
     TString buf = TBase64::Decode(inp_query.Data() + pos + 6);
     handler->fArg->SetPostData(std::string(buf.Data()));
     inp_query.Resize(pos);
  }
 
  handler->fArg->SetQuery(inp_query.Data());
 
  // just return handler
  return handler;
}
 
///////////////////////////////////////////////////////////////////////////////////////////////////
/// Generate URL for batch page
/// Uses file:/// prefix to let access JSROOT scripts placed on file system
/// Register provider for that page in resource manager
 
std::string GuiHandler::AddBatchPage(const std::string &cont)
{
   std::string url = "file:///batch_page";
   url.append(std::to_string(fBatchPageCount++));
   url.append(".html");
 
   fResourceManager->AddContentProvider(url, cont, "text/html", 0, std::string());
   return url;
}
 
///////////////////////////////////////////////////////////////////////////////////////////////////
/// Generate URL for RWebWindow page
/// Register server instance and assign it with the index
/// Produced URL only works inside CEF and does not represent real HTTP address
 
std::string GuiHandler::MakePageUrl(THttpServer *serv, const std::string &addr)
{
   unsigned indx = 0;
   while ((indx < fServers.size()) && (fServers[indx] != serv)) indx++;
   if (indx >= fServers.size()) {
      fServers.emplace_back(serv);
      indx = fServers.size() - 1;
   }
 
   return std::string("http://rootserver.local") + std::to_string(indx) + addr;
}