void InspectorLayerTreeAgent::profileSnapshot(
    ErrorString* errorString,
    const String& snapshotId,
    const protocol::Maybe<int>& minRepeatCount,
    const protocol::Maybe<double>& minDuration,
    const Maybe<protocol::DOM::Rect>& clipRect,
    std::unique_ptr<protocol::Array<protocol::Array<double>>>* outTimings) {
  const PictureSnapshot* snapshot = snapshotById(errorString, snapshotId);
  if (!snapshot)
    return;
  FloatRect rect;
  if (clipRect.isJust())
    parseRect(clipRect.fromJust(), &rect);
  std::unique_ptr<PictureSnapshot::Timings> timings =
      snapshot->profile(minRepeatCount.fromMaybe(1), minDuration.fromMaybe(0),
                        clipRect.isJust() ? &rect : 0);
  *outTimings = Array<Array<double>>::create();
  for (size_t i = 0; i < timings->size(); ++i) {
    const Vector<double>& row = (*timings)[i];
    std::unique_ptr<Array<double>> outRow = Array<double>::create();
    for (size_t j = 0; j < row.size(); ++j)
      outRow->addItem(row[j]);
    (*outTimings)->addItem(std::move(outRow));
  }
}
void V8HeapProfilerAgentImpl::getObjectByHeapObjectId(ErrorString* error, const String16& heapSnapshotObjectId, const protocol::Maybe<String16>& objectGroup, std::unique_ptr<protocol::Runtime::RemoteObject>* result)
{
    bool ok;
    int id = heapSnapshotObjectId.toInt(&ok);
    if (!ok) {
        *error = "Invalid heap snapshot object id";
        return;
    }

    v8::HandleScope handles(m_isolate);
    v8::Local<v8::Object> heapObject = objectByHeapObjectId(m_isolate, id);
    if (heapObject.IsEmpty()) {
        *error = "Object is not available";
        return;
    }

    if (!m_session->inspector()->client()->isInspectableHeapObject(heapObject)) {
        *error = "Object is not available";
        return;
    }

    *result = m_session->wrapObject(heapObject->CreationContext(), heapObject, objectGroup.fromMaybe(""), false);
    if (!result)
        *error = "Object is not available";
}
void V8HeapProfilerAgentImpl::startTrackingHeapObjects(ErrorString*, const protocol::Maybe<bool>& trackAllocations)
{
    m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled, true);
    bool allocationTrackingEnabled = trackAllocations.fromMaybe(false);
    m_state->setBoolean(HeapProfilerAgentState::allocationTrackingEnabled, allocationTrackingEnabled);
    startTrackingHeapObjectsInternal(allocationTrackingEnabled);
}
void V8HeapProfilerAgentImpl::takeHeapSnapshot(ErrorString* errorString, const protocol::Maybe<bool>& reportProgress)
{
    v8::HeapProfiler* profiler = m_isolate->GetHeapProfiler();
    if (!profiler) {
        *errorString = "Cannot access v8 heap profiler";
        return;
    }
    std::unique_ptr<HeapSnapshotProgress> progress;
    if (reportProgress.fromMaybe(false))
        progress = wrapUnique(new HeapSnapshotProgress(&m_frontend));

    GlobalObjectNameResolver resolver(m_session);
    const v8::HeapSnapshot* snapshot = profiler->TakeHeapSnapshot(progress.get(), &resolver);
    if (!snapshot) {
        *errorString = "Failed to take heap snapshot";
        return;
    }
    HeapSnapshotOutputStream stream(&m_frontend);
    snapshot->Serialize(&stream);
    const_cast<v8::HeapSnapshot*>(snapshot)->Delete();
}
Beispiel #5
0
Response InspectorInputAgent::dispatchTouchEvent(
    const String& type,
    std::unique_ptr<protocol::Array<protocol::Input::TouchPoint>> touchPoints,
    protocol::Maybe<int> modifiers,
    protocol::Maybe<double> timestamp) {
  PlatformEvent::EventType convertedType;
  if (type == "touchStart")
    convertedType = PlatformEvent::TouchStart;
  else if (type == "touchEnd")
    convertedType = PlatformEvent::TouchEnd;
  else if (type == "touchMove")
    convertedType = PlatformEvent::TouchMove;
  else
    return Response::Error(String("Unrecognized type: " + type));

  unsigned convertedModifiers = GetEventModifiers(modifiers.fromMaybe(0));

  SyntheticInspectorTouchEvent event(convertedType, convertedModifiers,
                                     GetEventTimeStamp(timestamp));

  int autoId = 0;
  for (size_t i = 0; i < touchPoints->length(); ++i) {
    protocol::Input::TouchPoint* point = touchPoints->get(i);
    int radiusX = point->getRadiusX(1);
    int radiusY = point->getRadiusY(1);
    double rotationAngle = point->getRotationAngle(0.0);
    double force = point->getForce(1.0);
    int id;
    if (point->hasId()) {
      if (autoId > 0)
        id = -1;
      else
        id = point->getId(0);
      autoId = -1;
    } else {
      id = autoId++;
    }
    if (id < 0) {
      return Response::Error(
          "All or none of the provided TouchPoints must supply positive "
          "integer ids.");
    }

    PlatformTouchPoint::TouchState convertedState;
    String state = point->getState();
    if (state == "touchPressed")
      convertedState = PlatformTouchPoint::TouchPressed;
    else if (state == "touchReleased")
      convertedState = PlatformTouchPoint::TouchReleased;
    else if (state == "touchMoved")
      convertedState = PlatformTouchPoint::TouchMoved;
    else if (state == "touchStationary")
      convertedState = PlatformTouchPoint::TouchStationary;
    else if (state == "touchCancelled")
      convertedState = PlatformTouchPoint::TouchCancelled;
    else
      return Response::Error(String("Unrecognized state: " + state));

    // Some platforms may have flipped coordinate systems, but the given
    // coordinates assume the origin is in the top-left of the window. Convert.
    IntPoint convertedPoint, globalPoint;
    ConvertInspectorPoint(m_inspectedFrames->root(),
                          IntPoint(point->getX(), point->getY()),
                          &convertedPoint, &globalPoint);

    SyntheticInspectorTouchPoint touchPoint(id++, convertedState, globalPoint,
                                            convertedPoint, radiusX, radiusY,
                                            rotationAngle, force);
    event.append(touchPoint);
  }

  // TODO: We need to add the support for generating coalesced events in
  // the devtools.
  Vector<PlatformTouchEvent> coalescedEvents;

  m_inspectedFrames->root()->eventHandler().handleTouchEvent(event,
                                                             coalescedEvents);
  return Response::OK();
}
void InspectorInputAgent::dispatchTouchEvent(ErrorString* error, const String& type, PassOwnPtr<protocol::Array<protocol::Input::TouchPoint>> touchPoints, const protocol::Maybe<int>& modifiers, const protocol::Maybe<double>& timestamp)
{
    PlatformEvent::Type convertedType;
    if (type == "touchStart") {
        convertedType = PlatformEvent::TouchStart;
    } else if (type == "touchEnd") {
        convertedType = PlatformEvent::TouchEnd;
    } else if (type == "touchMove") {
        convertedType = PlatformEvent::TouchMove;
    } else {
        *error = "Unrecognized type: " + type;
        return;
    }

    unsigned convertedModifiers = GetEventModifiers(modifiers.fromMaybe(0));

    SyntheticInspectorTouchEvent event(convertedType, convertedModifiers, timestamp.fromMaybe(currentTime()));

    int autoId = 0;
    for (size_t i = 0; i < touchPoints->length(); ++i) {
        protocol::Input::TouchPoint* point = touchPoints->get(i);
        int radiusX = point->getRadiusX(1);
        int radiusY = point->getRadiusY(1);
        double rotationAngle = point->getRotationAngle(0.0);
        double force = point->getForce(1.0);
        int id;
        if (point->hasId()) {
            if (autoId > 0)
                id = -1;
            else
                id = point->getId(0);
            autoId = -1;
        } else {
            id = autoId++;
        }
        if (id < 0) {
            *error = "All or none of the provided TouchPoints must supply positive integer ids.";
            return;
        }

        PlatformTouchPoint::State convertedState;
        String state = point->getState();
        if (state == "touchPressed") {
            convertedState = PlatformTouchPoint::TouchPressed;
        } else if (state == "touchReleased") {
            convertedState = PlatformTouchPoint::TouchReleased;
        } else if (state == "touchMoved") {
            convertedState = PlatformTouchPoint::TouchMoved;
        } else if (state == "touchStationary") {
            convertedState = PlatformTouchPoint::TouchStationary;
        } else if (state == "touchCancelled") {
            convertedState = PlatformTouchPoint::TouchCancelled;
        } else {
            *error = "Unrecognized state: " + state;
            return;
        }

        // Some platforms may have flipped coordinate systems, but the given coordinates
        // assume the origin is in the top-left of the window. Convert.
        IntPoint convertedPoint, globalPoint;
        ConvertInspectorPoint(m_inspectedFrames->root(), IntPoint(point->getX(), point->getY()), &convertedPoint, &globalPoint);

        SyntheticInspectorTouchPoint touchPoint(id++, convertedState, globalPoint, convertedPoint, radiusX, radiusY, rotationAngle, force);
        event.append(touchPoint);
    }

    m_inspectedFrames->root()->eventHandler().handleTouchEvent(event);
}