Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f581d1b9 authored by Joe Onorato's avatar Joe Onorato Committed by Android (Google) Code Review
Browse files

Merge changes from topic "b_132890298" into qt-dev 

* changes:
  Fix lookup of incident section by name to not crash.
  Add command line utilites to set the reason field in incident report header
  Add ProtoOutputStream.serializeToVector
parents 23ef465d 3864a348

cmds/incident/Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -30,7 +30,7 @@ cc_binary { 
    ],



    static_libs: [

        "libplatformprotos",

        "libprotoutil",

    ],



    cflags: [

cmds/incident/main.cpp

+26 −4
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <android/os/BnIncidentReportStatusListener.h>

#include <android/os/IIncidentManager.h>

#include <android/os/IncidentReportArgs.h>

#include <android/util/ProtoOutputStream.h>

#include <binder/IPCThreadState.h>

#include <binder/IServiceManager.h>

#include <utils/Looper.h>
@@ -36,6 +37,9 @@ using namespace android; 
using namespace android::base;

using namespace android::binder;

using namespace android::os;

using android::util::FIELD_COUNT_SINGLE;

using android::util::FIELD_TYPE_STRING;

using android::util::ProtoOutputStream;



// ================================================================================

class StatusListener : public BnIncidentReportStatusListener {
@@ -129,11 +133,11 @@ static void section_list(FILE* out) { 
static IncidentSection const*

find_section(const char* name)

{

    size_t low = 0;

    size_t high = INCIDENT_SECTION_COUNT - 1;

    ssize_t low = 0;

    ssize_t high = INCIDENT_SECTION_COUNT - 1;



    while (low <= high) {

        size_t mid = (low + high) >> 1;

        ssize_t mid = (low + high) / 2;

        IncidentSection const* section = INCIDENT_SECTIONS + mid;



        int cmp = strcmp(section->name, name);
@@ -208,6 +212,7 @@ usage(FILE* out) 
    fprintf(out, "and one of these destinations:\n");

    fprintf(out, "  -b           (default) print the report to stdout (in proto format)\n");

    fprintf(out, "  -d           send the report into dropbox\n");

    fprintf(out, "  -r REASON    human readable description of why the report is taken.\n");

    fprintf(out, "  -s PKG/CLS   send broadcast to the broadcast receiver.\n");

    fprintf(out, "\n");

    fprintf(out, "  SECTION     the field numbers of the incident report fields to include\n");
@@ -221,11 +226,12 @@ main(int argc, char** argv) 
    IncidentReportArgs args;

    enum { DEST_UNSET, DEST_DROPBOX, DEST_STDOUT, DEST_BROADCAST } destination = DEST_UNSET;

    int privacyPolicy = PRIVACY_POLICY_AUTOMATIC;

    string reason;

    string receiverArg;



    // Parse the args

    int opt;

    while ((opt = getopt(argc, argv, "bhdlp:s:")) != -1) {

    while ((opt = getopt(argc, argv, "bhdlp:r:s:")) != -1) {

        switch (opt) {

            case 'h':

                usage(stdout);
@@ -250,6 +256,13 @@ main(int argc, char** argv) 
            case 'p':

                privacyPolicy = get_privacy_policy(optarg);

                break;

            case 'r':

                if (reason.size() > 0) {

                    usage(stderr);

                    return 1;

                }

                reason = optarg;

                break;

            case 's':

                if (destination != DEST_UNSET) {

                    usage(stderr);
@@ -291,6 +304,7 @@ main(int argc, char** argv) 
                } else {

                    IncidentSection const* ic = find_section(arg);

                    if (ic == NULL) {

                        ALOGD("Invalid section: %s\n", arg);

                        fprintf(stderr, "Invalid section: %s\n", arg);

                        return 1;

                    }
@@ -301,6 +315,14 @@ main(int argc, char** argv) 
    }

    args.setPrivacyPolicy(privacyPolicy);



    if (reason.size() > 0) {

        ProtoOutputStream proto;

        proto.write(/* reason field id */ 2 | FIELD_TYPE_STRING | FIELD_COUNT_SINGLE, reason);

        vector<uint8_t> header;

        proto.serializeToVector(&header);

        args.addHeader(header);

    }



    // Start the thread pool.

    sp<ProcessState> ps(ProcessState::self());

    ps->startThreadPool();

libs/protoutil/include/android/util/ProtoOutputStream.h

+2 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 


#include <cstdint>

#include <string>

#include <vector>



#include <android/util/EncodedBuffer.h>
@@ -124,6 +125,7 @@ public: 
    sp<ProtoReader> data(); // Get the reader apis of the data.

    bool flush(int fd); // Flush data directly to a file descriptor.

    bool serializeToString(std::string* out); // Serializes the proto to a string.

    bool serializeToVector(std::vector<uint8_t>* out); // Serializes the proto to a vector<uint8_t>.



    /**

     * Clears the ProtoOutputStream so the buffer can be reused instead of deallocation/allocation again.

libs/protoutil/src/ProtoOutputStream.cpp

+17 −1
Original line number Diff line number Diff line
@@ -454,7 +454,6 @@ ProtoOutputStream::serializeToString(std::string* out) 
    if (out == nullptr) return false;

    if (!compact()) return false;





    sp<ProtoReader> reader = mBuffer->read();

    out->reserve(reader->size());

    while (reader->hasNext()) {
@@ -465,6 +464,23 @@ ProtoOutputStream::serializeToString(std::string* out) 
    return true;

}



bool

ProtoOutputStream::serializeToVector(std::vector<uint8_t>* out)

{

    if (out == nullptr) return false;

    if (!compact()) return false;



    sp<ProtoReader> reader = mBuffer->read();

    out->reserve(reader->size());

    while (reader->hasNext()) {

        const uint8_t* buf = reader->readBuffer();

        size_t size = reader->currentToRead();

        out->insert(out->end(), buf, buf + size);

        reader->move(size);

    }

    return true;

}



sp<ProtoReader>

ProtoOutputStream::data()

{

libs/protoutil/tests/ProtoOutputStream_test.cpp

+47 −0
Original line number Diff line number Diff line
@@ -132,6 +132,53 @@ TEST(ProtoOutputStreamTest, SerializeToStringPrimitives) { 
    EXPECT_EQ(primitives.val_enum(), PrimitiveProto_Count_TWO);

}



TEST(ProtoOutputStreamTest, SerializeToVectorPrimitives) {

    std::string s = "hello";

    const char b[5] = { 'a', 'p', 'p', 'l', 'e' };



    ProtoOutputStream proto;

    EXPECT_TRUE(proto.write(FIELD_TYPE_INT32 | PrimitiveProto::kValInt32FieldNumber, 123));

    EXPECT_TRUE(proto.write(FIELD_TYPE_INT64 | PrimitiveProto::kValInt64FieldNumber, -1LL));

    EXPECT_TRUE(proto.write(FIELD_TYPE_FLOAT | PrimitiveProto::kValFloatFieldNumber, -23.5f));

    EXPECT_TRUE(proto.write(FIELD_TYPE_DOUBLE | PrimitiveProto::kValDoubleFieldNumber, 324.5));

    EXPECT_TRUE(proto.write(FIELD_TYPE_UINT32 | PrimitiveProto::kValUint32FieldNumber, 3424));

    EXPECT_TRUE(proto.write(FIELD_TYPE_UINT64 | PrimitiveProto::kValUint64FieldNumber, 57LL));

    EXPECT_TRUE(proto.write(FIELD_TYPE_FIXED32 | PrimitiveProto::kValFixed32FieldNumber, -20));

    EXPECT_TRUE(proto.write(FIELD_TYPE_FIXED64 | PrimitiveProto::kValFixed64FieldNumber, -37LL));

    EXPECT_TRUE(proto.write(FIELD_TYPE_BOOL | PrimitiveProto::kValBoolFieldNumber, true));

    EXPECT_TRUE(proto.write(FIELD_TYPE_STRING | PrimitiveProto::kValStringFieldNumber, s));

    EXPECT_TRUE(proto.write(FIELD_TYPE_BYTES | PrimitiveProto::kValBytesFieldNumber, b, 5));

    EXPECT_TRUE(proto.write(FIELD_TYPE_SFIXED32 | PrimitiveProto::kValSfixed32FieldNumber, 63));

    EXPECT_TRUE(proto.write(FIELD_TYPE_SFIXED64 | PrimitiveProto::kValSfixed64FieldNumber, -54));

    EXPECT_TRUE(proto.write(FIELD_TYPE_SINT32 | PrimitiveProto::kValSint32FieldNumber, -533));

    EXPECT_TRUE(proto.write(FIELD_TYPE_SINT64 | PrimitiveProto::kValSint64FieldNumber, -61224762453LL));

    EXPECT_TRUE(proto.write(FIELD_TYPE_ENUM | PrimitiveProto::kValEnumFieldNumber, 2));



    PrimitiveProto primitives;

    std::vector<uint8_t> vec;

    ASSERT_TRUE(proto.serializeToVector(&vec));



    std::string serialized(vec.data(), vec.data() + vec.size());

    ASSERT_TRUE(primitives.ParseFromString(serialized));



    EXPECT_EQ(primitives.val_int32(), 123);

    EXPECT_EQ(primitives.val_int64(), -1);

    EXPECT_EQ(primitives.val_float(), -23.5f);

    EXPECT_EQ(primitives.val_double(), 324.5f);

    EXPECT_EQ(primitives.val_uint32(), 3424);

    EXPECT_EQ(primitives.val_uint64(), 57);

    EXPECT_EQ(primitives.val_fixed32(), -20);

    EXPECT_EQ(primitives.val_fixed64(), -37);

    EXPECT_EQ(primitives.val_bool(), true);

    EXPECT_THAT(primitives.val_string(), StrEq(s.c_str()));

    EXPECT_THAT(primitives.val_bytes(), StrEq("apple"));

    EXPECT_EQ(primitives.val_sfixed32(), 63);

    EXPECT_EQ(primitives.val_sfixed64(), -54);

    EXPECT_EQ(primitives.val_sint32(), -533);

    EXPECT_EQ(primitives.val_sint64(), -61224762453LL);

    EXPECT_EQ(primitives.val_enum(), PrimitiveProto_Count_TWO);

}



TEST(ProtoOutputStreamTest, Complex) {

    std::string name1 = "cat";

    std::string name2 = "dog";