C++ WebString::utf8方法代码示例

// The output from all these methods matches what DumpRenderTree produces.
bool NotificationPresenter::show(const WebNotification& notification)
{
    WebString identifier = identifierForNotification(notification);
    if (!notification.replaceId().isEmpty()) {
        string replaceId(notification.replaceId().utf8());
        if (m_replacements.find(replaceId) != m_replacements.end())
            m_delegate->printMessage(string("REPLACING NOTIFICATION ") + m_replacements.find(replaceId)->second + "\n");

        m_replacements[replaceId] = identifier.utf8();
    }

    if (notification.isHTML())
        m_delegate->printMessage(string("DESKTOP NOTIFICATION: contents at ") + string(notification.url().spec()) + "\n");
    else {
        m_delegate->printMessage("DESKTOP NOTIFICATION:");
        m_delegate->printMessage(notification.direction() == WebTextDirectionRightToLeft ? "(RTL)" : "");
        m_delegate->printMessage(" icon ");
        m_delegate->printMessage(notification.iconURL().isEmpty() ? "" : notification.iconURL().spec().data());
        m_delegate->printMessage(", title ");
        m_delegate->printMessage(notification.title().isEmpty() ? "" : notification.title().utf8().data());
        m_delegate->printMessage(", text ");
        m_delegate->printMessage(notification.body().isEmpty() ? "" : notification.body().utf8().data());
        m_delegate->printMessage("\n");
    }

    string id(identifier.utf8());
    m_activeNotifications[id] = notification;

    Platform::current()->callOnMainThread(deferredDisplayDispatch, new WebNotification(notification));
    return true;
}

TEST_F(FrameThrottlingTest, DumpThrottledFrame) {
  webView().settings()->setJavaScriptEnabled(true);

  // Create a frame which is throttled.
  SimRequest mainResource("https://example.com/", "text/html");
  SimRequest frameResource("https://example.com/iframe.html", "text/html");

  loadURL("https://example.com/");
  mainResource.complete(
      "main <iframe id=frame sandbox=allow-scripts src=iframe.html></iframe>");
  frameResource.complete("");
  auto* frameElement = toHTMLIFrameElement(document().getElementById("frame"));
  frameElement->setAttribute(styleAttr, "transform: translateY(480px)");
  compositeFrame();
  EXPECT_TRUE(frameElement->contentDocument()->view()->canThrottleRendering());

  LocalFrame* localFrame = toLocalFrame(frameElement->contentFrame());
  localFrame->script().executeScriptInMainWorld(
      "document.body.innerHTML = 'throttled'");
  EXPECT_FALSE(compositor().needsBeginFrame());

  // The dumped contents should not include the throttled frame.
  DocumentLifecycle::AllowThrottlingScope throttlingScope(
      document().lifecycle());
  WebString result = WebFrameContentDumper::deprecatedDumpFrameTreeAsText(
      webView().mainFrameImpl(), 1024);
  EXPECT_NE(std::string::npos, result.utf8().find("main"));
  EXPECT_EQ(std::string::npos, result.utf8().find("throttled"));
}

void NotificationPresenter::cancel(const WebNotification& notification)
{
    WebString identifier = identifierForNotification(notification);
    m_delegate->printMessage(string("DESKTOP NOTIFICATION CLOSED: ") + string(identifier.utf8()) + "\n");
    WebNotification eventTarget(notification);
    eventTarget.dispatchCloseEvent(false);

    string id(identifier.utf8());
    m_activeNotifications.erase(id);
}

void registerMockedURLLoad(const WebURL& fullURL, const WebString& fileName, const WebString& relativeBaseDirectory, const WebString& mimeType)
{
    WebURLResponse response(fullURL);
    response.setMIMEType(mimeType);
    response.setHTTPStatusCode(200);

    // Physical file path for the mock = <webkitRootDir> + relativeBaseDirectory + fileName.
    std::string filePath = std::string(Platform::current()->unitTestSupport()->webKitRootDir().utf8().data());
    filePath.append("/engine/web/tests/data/");
    filePath.append(std::string(relativeBaseDirectory.utf8().data()));
    filePath.append(std::string(fileName.utf8().data()));

    Platform::current()->unitTestSupport()->registerMockedURL(fullURL, response, WebString::fromUTF8(filePath.c_str()));
}

void WebViewHost::setStatusText(const WebString& text)
{
    if (!layoutTestController()->shouldDumpStatusCallbacks())
        return;
    // When running tests, write to stdout.
    printf("UI DELEGATE STATUS CALLBACK: setStatusText:%s\n", text.utf8().data());
}

WebNotificationPresenter::Permission NotificationPresenter::checkPermission(const WebSecurityOrigin& origin)
{
    // Check with the layout test controller
    WebString originString = origin.toString();
    bool allowed = m_allowedOrigins.find(string(originString.utf8())) != m_allowedOrigins.end();
    return allowed ? WebNotificationPresenter::PermissionAllowed
        : WebNotificationPresenter::PermissionDenied;
}

bool WebViewHost::shouldApplyStyle(const WebString& style, const WebRange& range)
{
    if (layoutTestController()->shouldDumpEditingCallbacks()) {
        printf("EDITING DELEGATE: shouldApplyStyle:%s toElementsInDOMRange:", style.utf8().data());
        printRangeDescription(range);
        fputs("\n", stdout);
    }
    return layoutTestController()->acceptsEditing();
}

bool WebViewHost::shouldInsertText(const WebString& text, const WebRange& range, WebEditingAction action)
{
    if (layoutTestController()->shouldDumpEditingCallbacks()) {
        printf("EDITING DELEGATE: shouldInsertText:%s replacingDOMRange:", text.utf8().data());
        printRangeDescription(range);
        printf(" givenAction:%s\n", editingActionDescription(action).c_str());
    }
    return layoutTestController()->acceptsEditing();
}

void NotificationPresenter::cancel(const WebNotification& notification)
{
    WebString identifier = identifierForNotification(notification);
    printf("DESKTOP NOTIFICATION CLOSED: %s\n", identifier.utf8().data());
    WebNotification eventTarget(notification);
    eventTarget.dispatchCloseEvent(false);

    WTF::String id(identifier.data(), identifier.length());
    m_activeNotifications.remove(id);
}

bool NotificationPresenter::simulateClick(const WebString& title)
{
    string id(title.utf8());
    if (m_activeNotifications.find(id) == m_activeNotifications.end())
        return false;

    const WebNotification& notification = m_activeNotifications.find(id)->second;
    WebNotification eventTarget(notification);
    eventTarget.dispatchClickEvent();
    return true;
}

void EventSender::dumpFilenameBeingDragged(const CppArgumentList&, CppVariant*)
{
    WebString filename;
    WebVector<WebDragData::Item> items = currentDragData.items();
    for (size_t i = 0; i < items.size(); ++i) {
        if (items[i].storageType == WebDragData::Item::StorageTypeBinaryData) {
            filename = items[i].title;
            break;
        }
    }
    printf("Filename being dragged: %s\n", filename.utf8().data());
}

void LayoutTestController::counterValueForElementById(const CppArgumentList& arguments, CppVariant* result)
{
    result->setNull();
    if (arguments.size() < 1 || !arguments[0].isString())
        return;
    WebFrame* frame = m_shell->webView()->mainFrame();
    if (!frame)
        return;
    WebString counterValue = frame->counterValueForElementById(cppVariantToWebString(arguments[0]));
    if (counterValue.isNull())
        return;
    result->set(counterValue.utf8());
}

void MockWebSpeechInputController::addMockRecognitionResult(const WebString& result, double confidence, const WebString& language)
{
    WebSpeechInputResult res;
    res.assign(result, confidence);

    if (language.isEmpty())
        m_resultsForEmptyLanguage.push_back(res);
    else {
        string langString = language.utf8();
        if (m_recognitionResults.find(langString) == m_recognitionResults.end())
            m_recognitionResults[langString] = vector<WebSpeechInputResult>();
        m_recognitionResults[langString].push_back(res);
    }
}

void WebViewHost::didReceiveTitle(WebFrame* frame, const WebString& title)
{
    WebCString title8 = title.utf8();

    if (m_shell->shouldDumpFrameLoadCallbacks()) {
        printFrameDescription(frame);
        printf(" - didReceiveTitle: %s\n", title8.data());
    }

    if (layoutTestController()->shouldDumpTitleChanges())
        printf("TITLE CHANGED: %s\n", title8.data());

    setPageTitle(title);
}

bool MockWebSpeechInputController::startRecognition(int requestId, const WebRect& elementRect, const WebString& language, const WebString& grammar, const WebSecurityOrigin& origin)
{
    if (m_speechTask)
        return false;

    m_requestId = requestId;
    m_requestRect = elementRect;
    m_recording = true;
    m_language = language.utf8();

    m_speechTask = new SpeechTask(this);
    m_delegate->postTask(m_speechTask);

    return true;
}