Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(838)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/websockets/websocket_frame_parser_unittest.cc

Issue 9956013: Add WebSocketFrameParser. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Address comments, add tests. Created 8 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/websockets/websocket_frame_parser.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/websockets/websocket_frame_parser_unittest.cc
diff --git a/net/websockets/websocket_frame_parser_unittest.cc b/net/websockets/websocket_frame_parser_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2eec894ac8f459693b59ddf94c4709c821ea0a82
--- /dev/null
+++ b/net/websockets/websocket_frame_parser_unittest.cc
@@ -0,0 +1,511 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/websockets/websocket_frame_parser.h"
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/port.h"
+#include "base/memory/scoped_vector.h"
+#include "net/websockets/websocket_frame.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+const char kHello[] = "Hello, world!";
+const uint64 kHelloLength = arraysize(kHello) - 1;
+const char kHelloFrame[] = "\x81\x0dHello, world!";
+const uint64 kHelloFrameLength = arraysize(kHelloFrame) - 1;
+const char kMaskedHelloFrame[] =
+ "\x81\x8d\xde\xad\xbe\xef"
+ "\x96\xc8\xd2\x83\xb1\x81\x9e\x98\xb1\xdf\xd2\x8b\xff";
+const uint64 kMaskedHelloFrameLength = arraysize(kMaskedHelloFrame) - 1;
+
+struct FrameHeaderTestCase {
+ const char* frame_header;
+ size_t frame_header_length;
+ uint64 frame_length;
+};
+
+const FrameHeaderTestCase kFrameHeaderTests[] = {
+ { "\x81\x00", 2, GG_UINT64_C(0) },
+ { "\x81\x7D", 2, GG_UINT64_C(125) },
+ { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126) },
+ { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF) },
+ { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, GG_UINT64_C(0x10000) },
+ { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10,
+ GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
+};
Takashi Toyoshima 2012/04/12 06:08:50 [optional] Hex values in this array are written in
Yuta Kitamura 2012/05/01 09:49:46 Fixed; used capital everywhere.
+const int kNumFrameHeaderTests = arraysize(kFrameHeaderTests);
+
+} // Unnamed namespace
+
+namespace net {
+
+TEST(WebSocketFrameParserTest, DecodeNormalFrame) {
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames;
+ EXPECT_TRUE(parser.Decode(kHelloFrame, kHelloFrameLength, &frames));
+ EXPECT_FALSE(parser.failed());
+ ASSERT_EQ(1u, frames.size());
+ WebSocketPartialFrame* frame = frames[0];
+ ASSERT_TRUE(frame != NULL);
+ const WebSocketFrameHeader* header = frame->header.get();
+ EXPECT_TRUE(header != NULL);
+ if (header) {
+ EXPECT_TRUE(header->final);
+ EXPECT_FALSE(header->reserved1);
+ EXPECT_FALSE(header->reserved2);
+ EXPECT_FALSE(header->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+ EXPECT_FALSE(header->masked);
+ EXPECT_EQ(kHelloLength, header->payload_length);
+ }
+ EXPECT_TRUE(frame->final_part);
+
+ std::vector<char> expected_data(kHello, kHello + kHelloLength);
+ EXPECT_EQ(expected_data, frame->data);
+}
+
+TEST(WebSocketFrameParserTest, DecodeMaskedFrame) {
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames;
+ EXPECT_TRUE(parser.Decode(kMaskedHelloFrame, kMaskedHelloFrameLength,
+ &frames));
+ EXPECT_FALSE(parser.failed());
+ ASSERT_EQ(1u, frames.size());
+ WebSocketPartialFrame* frame = frames[0];
+ ASSERT_TRUE(frame != NULL);
+ const WebSocketFrameHeader* header = frame->header.get();
+ EXPECT_TRUE(header != NULL);
+ if (header) {
+ EXPECT_TRUE(header->final);
+ EXPECT_FALSE(header->reserved1);
+ EXPECT_FALSE(header->reserved2);
+ EXPECT_FALSE(header->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+ EXPECT_TRUE(header->masked);
+ EXPECT_EQ(kHelloLength, header->payload_length);
+ }
+ EXPECT_TRUE(frame->final_part);
+
+ std::vector<char> expected_data(kHello, kHello + kHelloLength);
+ EXPECT_EQ(expected_data, frame->data);
+}
+
+TEST(WebSocketFrameParserTest, DecodeManyFrames) {
+ static const int kRepeat = 10;
+
+ std::vector<char> input;
+ for (int i = 0; i < kRepeat; ++i)
+ input.insert(input.end(), kHelloFrame, kHelloFrame + kHelloFrameLength);
+
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames;
+ EXPECT_TRUE(parser.Decode(&input.front(), input.size(), &frames));
+ EXPECT_FALSE(parser.failed());
+ EXPECT_EQ(static_cast<size_t>(kRepeat), frames.size());
+
+ std::vector<char> expected_data(kHello, kHello + kHelloLength);
+
+ for (size_t i = 0; i < frames.size(); ++i) {
+ WebSocketPartialFrame* frame = frames[i];
+ EXPECT_TRUE(frame != NULL);
+ if (!frame)
+ continue;
+ EXPECT_TRUE(frame->final_part);
+ EXPECT_EQ(expected_data, frame->data);
+
+ const WebSocketFrameHeader* header = frame->header.get();
+ EXPECT_TRUE(header != NULL);
+ if (!header)
+ continue;
+ EXPECT_TRUE(header->final);
+ EXPECT_FALSE(header->reserved1);
+ EXPECT_FALSE(header->reserved2);
+ EXPECT_FALSE(header->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+ EXPECT_FALSE(header->masked);
+ EXPECT_EQ(kHelloLength, header->payload_length);
+ }
+}
+
+TEST(WebSocketFrameParserTest, DecodePartialFrame) {
+ static const size_t kFrameHeaderSize = 2;
+
+ for (size_t cutting_pos = 0; cutting_pos < kHelloLength - 1; ++cutting_pos) {
+ std::vector<char> input1(kHelloFrame,
+ kHelloFrame + kFrameHeaderSize + cutting_pos);
+ std::vector<char> input2(kHelloFrame + input1.size(),
+ kHelloFrame + kHelloFrameLength);
+
+ std::vector<char> expected1(kHello, kHello + cutting_pos);
+ std::vector<char> expected2(kHello + cutting_pos, kHello + kHelloLength);
+
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames1;
+ EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1));
+ EXPECT_FALSE(parser.failed());
+ EXPECT_EQ(1u, frames1.size());
+ if (frames1.size() != 1u)
+ continue;
+ WebSocketPartialFrame* frame1 = frames1[0];
+ EXPECT_TRUE(frame1 != NULL);
+ if (!frame1)
+ continue;
+ EXPECT_FALSE(frame1->final_part);
+ EXPECT_EQ(expected1, frame1->data);
+ const WebSocketFrameHeader* header1 = frame1->header.get();
+ EXPECT_TRUE(header1 != NULL);
+ if (!header1)
+ continue;
+ EXPECT_TRUE(header1->final);
+ EXPECT_FALSE(header1->reserved1);
+ EXPECT_FALSE(header1->reserved2);
+ EXPECT_FALSE(header1->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode);
+ EXPECT_FALSE(header1->masked);
+ EXPECT_EQ(kHelloLength, header1->payload_length);
+
+ ScopedVector<WebSocketPartialFrame> frames2;
+ EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
+ EXPECT_FALSE(parser.failed());
+ EXPECT_EQ(1u, frames2.size());
+ if (frames2.size() != 1u)
+ continue;
+ WebSocketPartialFrame* frame2 = frames2[0];
+ EXPECT_TRUE(frame2 != NULL);
+ if (!frame2)
+ continue;
+ EXPECT_TRUE(frame2->final_part);
+ EXPECT_EQ(expected2, frame2->data);
+ const WebSocketFrameHeader* header2 = frame2->header.get();
+ EXPECT_TRUE(header2 != NULL);
+ EXPECT_EQ(header1, header2);
+ if (!header2)
+ continue;
+ EXPECT_TRUE(header2->final);
+ EXPECT_FALSE(header2->reserved1);
+ EXPECT_FALSE(header2->reserved2);
+ EXPECT_FALSE(header2->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header2->opcode);
+ EXPECT_FALSE(header2->masked);
+ EXPECT_EQ(kHelloLength, header2->payload_length);
+ }
+}
+
+TEST(WebSocketFrameParserTest, DecodePartialMaskedFrame) {
+ static const size_t kFrameHeaderSize = 6;
+
+ for (size_t cutting_pos = 0; cutting_pos < kHelloLength - 1; ++cutting_pos) {
+ std::vector<char> input1(
+ kMaskedHelloFrame,
+ kMaskedHelloFrame + kFrameHeaderSize + cutting_pos);
+ std::vector<char> input2(kMaskedHelloFrame + input1.size(),
+ kMaskedHelloFrame + kMaskedHelloFrameLength);
+
+ std::vector<char> expected1(kHello, kHello + cutting_pos);
+ std::vector<char> expected2(kHello + cutting_pos, kHello + kHelloLength);
+
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames1;
+ EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1));
+ EXPECT_FALSE(parser.failed());
+ EXPECT_EQ(1u, frames1.size());
+ if (frames1.size() != 1u)
+ continue;
+ WebSocketPartialFrame* frame1 = frames1[0];
+ EXPECT_TRUE(frame1 != NULL);
+ if (!frame1)
+ continue;
+ EXPECT_FALSE(frame1->final_part);
+ EXPECT_EQ(expected1, frame1->data);
+ const WebSocketFrameHeader* header1 = frame1->header.get();
+ EXPECT_TRUE(header1 != NULL);
+ if (!header1)
+ continue;
+ EXPECT_TRUE(header1->final);
+ EXPECT_FALSE(header1->reserved1);
+ EXPECT_FALSE(header1->reserved2);
+ EXPECT_FALSE(header1->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode);
+ EXPECT_TRUE(header1->masked);
+ EXPECT_EQ(kHelloLength, header1->payload_length);
+
+ ScopedVector<WebSocketPartialFrame> frames2;
+ EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
+ EXPECT_FALSE(parser.failed());
+ EXPECT_EQ(1u, frames2.size());
+ if (frames2.size() != 1u)
+ continue;
+ WebSocketPartialFrame* frame2 = frames2[0];
+ EXPECT_TRUE(frame2 != NULL);
+ if (!frame2)
+ continue;
+ EXPECT_TRUE(frame2->final_part);
+ EXPECT_EQ(expected2, frame2->data);
+ const WebSocketFrameHeader* header2 = frame2->header.get();
+ EXPECT_TRUE(header2 != NULL);
+ EXPECT_EQ(header1, header2);
+ if (!header2)
+ continue;
+ EXPECT_TRUE(header2->final);
+ EXPECT_FALSE(header2->reserved1);
+ EXPECT_FALSE(header2->reserved2);
+ EXPECT_FALSE(header2->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header2->opcode);
+ EXPECT_TRUE(header2->masked);
+ EXPECT_EQ(kHelloLength, header2->payload_length);
+ }
+}
+
+TEST(WebSocketFrameParserTest, DecodeFramesOfVariousLengths) {
+ for (int i = 0; i < kNumFrameHeaderTests; ++i) {
+ const char* frame_header = kFrameHeaderTests[i].frame_header;
+ size_t frame_header_length = kFrameHeaderTests[i].frame_header_length;
+ uint64 frame_length = kFrameHeaderTests[i].frame_length;
+
+ std::vector<char> input(frame_header, frame_header + frame_header_length);
+ // Limit the payload size not to flood the console on failure.
+ static const uint64 kMaxPayloadSize = 200;
+ uint64 input_payload_size = std::min(frame_length, kMaxPayloadSize);
+ input.insert(input.end(), input_payload_size, 'a');
+
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames;
+ EXPECT_TRUE(parser.Decode(&input.front(), input.size(), &frames));
+ EXPECT_FALSE(parser.failed());
+ EXPECT_EQ(1u, frames.size());
+ if (frames.size() != 1u)
+ continue;
+ WebSocketPartialFrame* frame = frames[0];
+ EXPECT_TRUE(frame != NULL);
+ if (!frame)
+ continue;
+ if (frame_length == input_payload_size)
+ EXPECT_TRUE(frame->final_part);
+ else
+ EXPECT_FALSE(frame->final_part);
+ std::vector<char> expected_payload(input_payload_size, 'a');
+ EXPECT_EQ(expected_payload, frame->data);
+ const WebSocketFrameHeader* header = frame->header.get();
+ EXPECT_TRUE(header != NULL);
+ if (!header)
+ continue;
+ EXPECT_TRUE(header->final);
+ EXPECT_FALSE(header->reserved1);
+ EXPECT_FALSE(header->reserved2);
+ EXPECT_FALSE(header->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+ EXPECT_FALSE(header->masked);
+ EXPECT_EQ(frame_length, header->payload_length);
+ }
+}
+
+TEST(WebSocketFrameParserTest, DecodePartialHeader) {
+ for (int i = 0; i < kNumFrameHeaderTests; ++i) {
+ const char* frame_header = kFrameHeaderTests[i].frame_header;
+ size_t frame_header_length = kFrameHeaderTests[i].frame_header_length;
+ uint64 frame_length = kFrameHeaderTests[i].frame_length;
+
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames;
+ // Feed each byte to the parser to see if the parser behaves correctly
+ // when it receives partial frame header.
+ for (size_t j = 0; j < frame_header_length; ++j) {
+ EXPECT_TRUE(parser.Decode(frame_header + j, 1, &frames));
+ EXPECT_FALSE(parser.failed());
+ if (j == frame_header_length - 1)
+ EXPECT_EQ(1u, frames.size());
+ else
+ EXPECT_EQ(0u, frames.size());
+ }
+ if (frames.size() != 1u)
+ continue;
+ WebSocketPartialFrame* frame = frames[0];
+ EXPECT_TRUE(frame != NULL);
+ if (!frame)
+ continue;
+ if (frame_length == 0u)
+ EXPECT_TRUE(frame->final_part);
+ else
+ EXPECT_FALSE(frame->final_part);
+ EXPECT_EQ(std::vector<char>(), frame->data);
+ const WebSocketFrameHeader* header = frame->header.get();
+ EXPECT_TRUE(header != NULL);
+ if (!header)
+ continue;
+ EXPECT_TRUE(header->final);
+ EXPECT_FALSE(header->reserved1);
+ EXPECT_FALSE(header->reserved2);
+ EXPECT_FALSE(header->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+ EXPECT_FALSE(header->masked);
+ EXPECT_EQ(frame_length, header->payload_length);
+ }
+}
+
+TEST(WebSocketFrameParserTest, InvalidLengthEncoding) {
+ struct TestCase {
+ const char* frame_header;
+ size_t frame_header_length;
+ };
+ static const TestCase kTests[] = {
+ // For frames with two-byte extended length field, the payload length
+ // should be 126 (0x7E) bytes or more.
+ { "\x81\x7E\x00\x00", 4 },
+ { "\x81\x7E\x00\x7D", 4 },
+ // For frames with eight-byte extended length field, the payload length
+ // should be 0x10000 bytes or more.
+ { "\x81\x7F\x00\x00\x00\x00\x00\x00\x00\x00", 10 },
+ { "\x81\x7E\x00\x00\x00\x00\x00\x00\xFF\xFF", 10 },
+ };
+ static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+
+ for (int i = 0; i < kNumTests; ++i) {
+ const char* frame_header = kTests[i].frame_header;
+ size_t frame_header_length = kTests[i].frame_header_length;
+
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames;
+ EXPECT_FALSE(parser.failed());
+ EXPECT_FALSE(parser.Decode(frame_header, frame_header_length, &frames));
+ EXPECT_TRUE(parser.failed());
+ EXPECT_EQ(0u, frames.size());
+
+ // Once the parser has failed, it no longer accepts any input (even if
+ // the input is empty).
+ EXPECT_FALSE(parser.Decode("", 0, &frames));
+ EXPECT_TRUE(parser.failed());
+ EXPECT_EQ(0u, frames.size());
+ }
+}
+
+TEST(WebSocketFrameParserTest, FrameTypes) {
+ struct TestCase {
+ const char* frame_header;
+ size_t frame_header_length;
+ WebSocketFrameHeader::OpCode opcode;
+ };
+ static const TestCase kTests[] = {
+ { "\x80\x00", 2, WebSocketFrameHeader::kOpCodeContinuation },
+ { "\x81\x00", 2, WebSocketFrameHeader::kOpCodeText },
+ { "\x82\x00", 2, WebSocketFrameHeader::kOpCodeBinary },
+ { "\x88\x00", 2, WebSocketFrameHeader::kOpCodeClose },
+ { "\x89\x00", 2, WebSocketFrameHeader::kOpCodePing },
+ { "\x8a\x00", 2, WebSocketFrameHeader::kOpCodePong },
+ // These are undefined opcodes, but the parser needs to be able to parse
+ // them anyway.
+ { "\x83\x00", 2, 0x3 },
+ { "\x84\x00", 2, 0x4 },
+ { "\x85\x00", 2, 0x5 },
+ { "\x86\x00", 2, 0x6 },
+ { "\x87\x00", 2, 0x7 },
+ { "\x8b\x00", 2, 0xb },
+ { "\x8c\x00", 2, 0xc },
+ { "\x8d\x00", 2, 0xd },
+ { "\x8e\x00", 2, 0xe },
+ { "\x8f\x00", 2, 0xf }
+ };
+ static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+
+ for (int i = 0; i < kNumTests; ++i) {
+ const char* frame_header = kTests[i].frame_header;
+ size_t frame_header_length = kTests[i].frame_header_length;
+ WebSocketFrameHeader::OpCode opcode = kTests[i].opcode;
+
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames;
+ EXPECT_TRUE(parser.Decode(frame_header, frame_header_length, &frames));
+ EXPECT_FALSE(parser.failed());
+ EXPECT_EQ(1u, frames.size());
+ if (frames.size() != 1u)
+ continue;
+ WebSocketPartialFrame* frame = frames[0];
+ EXPECT_TRUE(frame != NULL);
+ if (!frame)
+ continue;
+ EXPECT_TRUE(frame->final_part);
+ EXPECT_EQ(std::vector<char>(), frame->data);
+ const WebSocketFrameHeader* header = frame->header.get();
+ EXPECT_TRUE(header != NULL);
+ if (!header)
+ continue;
+ EXPECT_TRUE(header->final);
+ EXPECT_FALSE(header->reserved1);
+ EXPECT_FALSE(header->reserved2);
+ EXPECT_FALSE(header->reserved3);
+ EXPECT_EQ(opcode, header->opcode);
+ EXPECT_FALSE(header->masked);
+ EXPECT_EQ(0u, header->payload_length);
+ };
+}
+
+TEST(WebSocketFrameParserTest, FinalBitAndReservedBits) {
+ struct TestCase {
+ const char* frame_header;
+ size_t frame_header_length;
+ bool final;
+ bool reserved1;
+ bool reserved2;
+ bool reserved3;
+ };
+ static const TestCase kTests[] = {
+ { "\x81\x00", 2, true, false, false, false },
+ { "\x01\x00", 2, false, false, false, false },
+ { "\xC1\x00", 2, true, true, false, false },
+ { "\xA1\x00", 2, true, false, true, false },
+ { "\x91\x00", 2, true, false, false, true },
+ { "\x71\x00", 2, false, true, true, true },
+ { "\xF1\x00", 2, true, true, true, true }
+ };
+ static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+
+ for (int i = 0; i < kNumTests; ++i) {
+ const char* frame_header = kTests[i].frame_header;
+ size_t frame_header_length = kTests[i].frame_header_length;
+ bool final = kTests[i].final;
+ bool reserved1 = kTests[i].reserved1;
+ bool reserved2 = kTests[i].reserved2;
+ bool reserved3 = kTests[i].reserved3;
+
+ WebSocketFrameParser parser;
+
+ ScopedVector<WebSocketPartialFrame> frames;
+ EXPECT_TRUE(parser.Decode(frame_header, frame_header_length, &frames));
+ EXPECT_FALSE(parser.failed());
+ EXPECT_EQ(1u, frames.size());
+ if (frames.size() != 1u)
+ continue;
+ WebSocketPartialFrame* frame = frames[0];
+ EXPECT_TRUE(frame != NULL);
+ if (!frame)
+ continue;
+ EXPECT_TRUE(frame->final_part);
+ EXPECT_EQ(std::vector<char>(), frame->data);
+ const WebSocketFrameHeader* header = frame->header.get();
+ EXPECT_TRUE(header != NULL);
+ if (!header)
+ continue;
+ EXPECT_EQ(final, header->final);
+ EXPECT_EQ(reserved1, header->reserved1);
+ EXPECT_EQ(reserved2, header->reserved2);
+ EXPECT_EQ(reserved3, header->reserved3);
+ EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+ EXPECT_FALSE(header->masked);
+ EXPECT_EQ(0u, header->payload_length);
+ }
+}
+
+} // namespace net
« no previous file with comments | « net/websockets/websocket_frame_parser.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698