this method replaces connection.handleData when in record mode It accepts the raw connection data which is used to make a frame.
358533
function (frameData) {
      // Would be better to check controller.streaming() in showOverlay, but that method doesn't exist, yet.
      this.setGraphic('wave');
      if (frameData.hands.length > 0) {
        this.recording.addFrame(frameData);
        this.hideOverlay();
      } else if ( !this.recording.blank() ) {
        this.finishRecording();
      }
    }
306635
function (rawData) {
    var oldData = this.data;
    if (!Object.keys(schema).length) { return; }
    this.buildData(rawData);
    this.update(oldData);
  }
654488
def process_raw_data(cls, raw_data):
        """"""
        properties = raw_data["properties"]

        routes = []
        raw_routes = properties.get("routes", [])
        for raw_route in raw_routes:
            raw_route["parentResourceID"] = raw_data["resourceId"]
            routes.append(Routes.from_raw_data(raw_route))
        properties["routes"] = routes

        subnets = []
        raw_subnets = properties.get("subnets", [])
        for raw_subnet in raw_subnets:
            subnets.append(Resource.from_raw_data(raw_subnet))
        properties["subnets"] = subnets

        return super(RouteTables, cls).process_raw_data(raw_data)
1292280
def reconstruct_raw(self, rawdata):
        
        start, end = self._rawdata_bounds
        r = rawdata[start:end]
        delattr(self, '_rawdata_bounds')
        try:
            if self._order_list:
                order = to_numpy_list(self._order_list)
                r = r.get_indexed(order)
                delattr(self, '_order_list')
        except AttributeError:
            pass
        self.set_raw(r)
1215504
public void handle(Buffer buffer) {
        if (buff == null) {
            buff = buffer;
        } else {
            buff.appendBuffer(buffer);
        }

        if(recordSize == -1) {
            fixedSizeMode(buff.getInt(0) + 4);
        }

        handleParsing();
    }
1121037
function(rowIndex) {

      if(!this.dialog) {
         this.renderDialog();
      }

      // NOT Inserting new record
		this.insertNewRecord = false;
		
		// Set the selected Record
		this.selectedRecord = rowIndex;
		
		// Get the selected Record
		var record = this.datatable.getRecord(this.selectedRecord);
		
		this.dialog.whenFormAvailable({
			fn: function() {
				this.dialog.setValue(record.getData());
				this.dialog.show();
			},
			scope: this
		});
		
	}
267406
public int handlePutRawRecordData(Rec record)
    {
        int iErrorCode = Constant.NORMAL_RETURN;
        int iRecordCount = this.getRecordCount(record);
        
        Rec recTargetRecord = this.setDataIndex(RESET_INDEX, record);   // Reset index if multiple
        
        for (int index = 1; index <= iRecordCount; index++)
        {
            Rec recNext = this.setDataIndex(index, recTargetRecord);
            if (recNext == null)
                break;
            
            iErrorCode = super.handlePutRawRecordData(recNext);

            if (iErrorCode != Constant.NORMAL_RETURN)
                break;
        }
        this.setDataIndex(END_OF_NODES, recTargetRecord);
        return iErrorCode;
    }
210446
def process_raw_data(cls, raw_data):
        """"""
        properties = raw_data["properties"]
        qos_settings = properties.get("qosSettings", {})
        properties["qosSettings"] = VirtualSwtichQosSettings.from_raw_data(
            raw_data=qos_settings)
        return super(VirtualSwitchManager, cls).process_raw_data(raw_data)
1284981
def process_raw_data(cls, raw_data):
        """"""

        # pylint: disable=redefined-variable-type

        raw_content = raw_data.get("updateMessageStats", None)
        if raw_content is not None:
            statistics = UpdateMessageStatistics.from_raw_data(raw_content)
            raw_data["updateMessageStats"] = statistics

        raw_content = raw_data.get("routeRefreshMessageStats", None)
        if raw_content is not None:
            statistics = RouteRefreshMessageStatistics.from_raw_data(
                raw_content)
            raw_data["routeRefreshMessageStats"] = statistics

        raw_content = raw_data.get("keepAliveMessageStats", None)
        if raw_content is not None:
            statistics = KeepAliveMessageStatistics.from_raw_data(raw_content)
            raw_data["keepAliveMessageStats"] = statistics

        raw_content = raw_data.get("notificationMessageStats", None)
        if raw_content is not None:
            statistics = NotificationMessageStatistics.from_raw_data(
                raw_content)
            raw_data["notificationMessageStats"] = statistics

        raw_content = raw_data.get("openMessageStats", None)
        if raw_content is not None:
            statistics = OpenMessageStatistics.from_raw_data(raw_content)
            raw_data["openMessageStats"] = statistics

        raw_content = raw_data.get("ipv4Route", None)
        if raw_content is not None:
            statistics = IPV4Route.from_raw_data(raw_content)
            raw_data["ipv4Route"] = statistics

        raw_content = raw_data.get("ipv6Route", None)
        if raw_content is not None:
            statistics = IPV6Route.from_raw_data(raw_content)
            raw_data["ipv6Route"] = statistics

        return super(BGPPeersStatistics, cls).process_raw_data(raw_data)
168585
public void processCompleteFrame() throws Http2Exception {
        Frame currentFrame = getCurrentFrame();

        boolean frameSizeError = false;
        try {
            currentFrame.processPayload(this);
        } catch (Http2Exception e) {
            // If we get an error here, it should be safe to assume that this frame doesn't have the expected byte count,
            // which must be treated as an error of type FRAME_SIZE_ERROR.  If we're processing a DATA or PRIORITY frame, then
            // we can treat the error as a stream error rather than a connection error.
            if (!e.isConnectionError()) {
                frameSizeError = true;
            } else {
                // this is a connection error; we need to send a GOAWAY on the connection
                throw e;
            }
        } catch (Exception e) {
            throw new ProtocolException("Error processing the payload for " + currentFrame.getFrameType()
                                        + " frame on stream " + currentFrame.getStreamId());
        }

        // call the stream processor to process this stream. For now, don't return from here until the
        // frame has been fully processed.
        int streamId = currentFrame.getStreamId();
        H2StreamProcessor stream = muxLink.getStream(streamId);

        if (stream == null) {
            if ((streamId != 0) && (streamId % 2 == 0)) {
                if (currentFrame.getFrameType().equals(FrameTypes.PRIORITY)) {
                    // ignore PRIORITY frames in any state
                    return;
                } else if (currentFrame.getFrameType().equals(FrameTypes.RST_STREAM) && streamId < muxLink.getHighestClientStreamId()) {
                    // tolerate RST_STREAM frames that are sent on closed push streams
                    return;
                } else {
                    throw new ProtocolException("Cannot start a stream from the client with an even numbered ID. stream-id: " + streamId);
                }
            } else {
                stream = startNewInboundSession(streamId);
            }
        }
        if (frameSizeError) {
            currentFrame = new FrameRstStream(streamId, 4, (byte) 0, false, FrameDirection.READ);
            ((FrameRstStream) currentFrame).setErrorCode(Constants.FRAME_SIZE_ERROR);
        }

        stream.processNextFrame(currentFrame, Direction.READ_IN);
    }
472422
function(data, escapeHeaderValues) {
    const onFrame = jasmine.createSpy('onFrame');
    const onIncomingPing = jasmine.createSpy('onIncomingPing');
    const parser = new StompJs.Parser(onFrame, onIncomingPing);

    parser.parseChunk(data);

    const rawFrame = onFrame.calls.first().args[0];
    return StompJs.FrameImpl.fromRawFrame(rawFrame, escapeHeaderValues);
  }
291747
function handleImageData(handler, xref, res, image) {
    if (image instanceof JpegStream && image.isNativelyDecodable(xref, res)) {
      // For natively supported jpegs send them to the main thread for decoding.
      var dict = image.dict;
      var colorSpace = dict.get('ColorSpace', 'CS');
      colorSpace = ColorSpace.parse(colorSpace, xref, res);
      var numComps = colorSpace.numComps;
      var decodePromise = handler.sendWithPromise('JpegDecode',
                                                  [image.getIR(), numComps]);
      return decodePromise.then(function (message) {
        var data = message.data;
        return new Stream(data, 0, data.length, image.dict);
      });
    } else {
      return Promise.resolve(image);
    }
  }
1007457
def data_received(self, data):
        

        # First, add the data to the receive buffer
        self._recv_buf += data

        # Now, pass all frames we can find to the client protocol
        while self._recv_buf and not self._recv_paused:
            try:
                # Extract one frame
                frame = self._recv_framer.to_frame(self._recv_buf,
                                                   self._recv_state)
            except exc.NoFrames:
                # There's data in the buffer, but no complete frames
                break

            # Now call the client protocol's frame_received() method
            self._client.frame_received(frame)
637623
def on_connection_unblocked(self, method_frame):
        
        LOGGER.debug('Connection unblocked: %r', method_frame)
        self.state = self.STATE_READY
        if self.on_ready:
            self.on_ready(self)
174887
@Deprecated
    public void appendData(@Nullable T data) {
        Preconditions.checkState(mGroupBasicAdapter != null, "Must call bindView() first");

        appendData(mDataParser.parseGroup(data, this));
    }
238752
def _handle_raw_packet(self, raw_packet):
        """"""
        if raw_packet[1:2] == b'\x1f':
            self._reset_timeout()
            year = raw_packet[2]
            month = raw_packet[3]
            day = raw_packet[4]
            hour = raw_packet[5]
            minute = raw_packet[6]
            sec = raw_packet[7]
            week = raw_packet[8]
            self.logger.debug(
                'received date: Year: %s, Month: %s, Day: %s, Hour: %s, '
                'Minute: %s, Sec: %s, Week %s',
                year, month, day, hour, minute, sec, week)
        elif raw_packet[1:2] == b'\x0c':
            states = {}
            changes = []
            for switch in range(0, 16):
                if raw_packet[2+switch:3+switch] == b'\x01':
                    states[format(switch, 'x')] = True
                    if (self.client.states.get(format(switch, 'x'), None)
                            is not True):
                        changes.append(format(switch, 'x'))
                        self.client.states[format(switch, 'x')] = True
                elif raw_packet[2+switch:3+switch] == b'\x02':
                    states[format(switch, 'x')] = False
                    if (self.client.states.get(format(switch, 'x'), None)
                            is not False):
                        changes.append(format(switch, 'x'))
                        self.client.states[format(switch, 'x')] = False
            for switch in changes:
                for status_cb in self.client.status_callbacks.get(switch, []):
                    status_cb(states[switch])
            self.logger.debug(states)
            if self.client.in_transaction:
                self.client.in_transaction = False
                self.client.active_packet = False
                self.client.active_transaction.set_result(states)
                while self.client.status_waiters:
                    waiter = self.client.status_waiters.popleft()
                    waiter.set_result(states)
                if self.client.waiters:
                    self.send_packet()
                else:
                    self._cmd_timeout.cancel()
            elif self._cmd_timeout:
                self._cmd_timeout.cancel()
        else:
            self.logger.warning('received unknown packet: %s',
                                binascii.hexlify(raw_packet))
975463
function processRouteSampleData (o) {
  if (parseInt(o.rawDataPacket[0]) === k.OBCIGanglionByteIdUncompressed) {
    return processUncompressedData(o);
  } else {
    return processCompressedData(o);
  }
}