Google OAuth Device Flow support for FNL

mojo/dart/packages/mojo_services/lib/authentication/authentication_impl_db.mojom.dart

 // Copyright 2014 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.
 
-library http_request_mojom;
+library authentication_impl_db_mojom;
 import 'package:mojo/bindings.dart' as bindings;
-import 'package:mojo/core.dart' as core;
 
 
 
 
-class HttpRequest extends bindings.Struct {
+class Db extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(40, 0)
+    const bindings.StructDataHeader(24, 0)
   ];
-  String relativeUrl = null;
-  String method = "GET";
-  Map<String, String> headers = null;
-  core.MojoDataPipeConsumer body = null;
+  int version = 0;
+  Map<String, String> lastSelectedAccounts = null;
 
-  HttpRequest() : super(kVersions.last.size);
+  Db() : super(kVersions.last.size);
 
-  static HttpRequest deserialize(bindings.Message message) {
+  static Db deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
-  static HttpRequest decode(bindings.Decoder decoder0) {
+  static Db decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    HttpRequest result = new HttpRequest();
+    Db result = new Db();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
     if (mainDataHeader.version >= 0) {
       
-      result.relativeUrl = decoder0.decodeString(8, false);
+      result.version = decoder0.decodeUint32(8);
     }
     if (mainDataHeader.version >= 0) {
       
-      result.method = decoder0.decodeString(16, false);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      var decoder1 = decoder0.decodePointer(24, true);
-      if (decoder1 == null) {
-        result.headers = null;
-      } else {
+      var decoder1 = decoder0.decodePointer(16, false);
+      {
         decoder1.decodeDataHeaderForMap();
         List<String> keys0;
         List<String> values0;
         {
           
           var decoder2 = decoder1.decodePointer(bindings.ArrayDataHeader.kHeaderSize, false);
           {
             var si2 = decoder2.decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength);
             keys0 = new List<String>(si2.numElements);
             for (int i2 = 0; i2 < si2.numElements; ++i2) {
               
               keys0[i2] = decoder2.decodeString(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i2, false);
             }
           }
         }
         {
           
           var decoder2 = decoder1.decodePointer(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize, false);
           {
             var si2 = decoder2.decodeDataHeaderForPointerArray(keys0.length);
             values0 = new List<String>(si2.numElements);
             for (int i2 = 0; i2 < si2.numElements; ++i2) {
               
               values0[i2] = decoder2.decodeString(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i2, false);
             }
           }
         }
-        result.headers = new Map<String, String>.fromIterables(
+        result.lastSelectedAccounts = new Map<String, String>.fromIterables(
             keys0, values0);
       }
     }
-    if (mainDataHeader.version >= 0) {
-      
-      result.body = decoder0.decodeConsumerHandle(32, true);
-    }
     return result;
   }
 
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     try {
-      encoder0.encodeString(relativeUrl, 8, false);
+      encoder0.encodeUint32(version, 8);
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "relativeUrl of struct HttpRequest: $e";
+          "version of struct Db: $e";
       rethrow;
     }
     try {
-      encoder0.encodeString(method, 16, false);
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "method of struct HttpRequest: $e";
-      rethrow;
-    }
-    try {
-      if (headers == null) {
-        encoder0.encodeNullPointer(24, true);
+      if (lastSelectedAccounts == null) {
+        encoder0.encodeNullPointer(16, false);
       } else {
-        var encoder1 = encoder0.encoderForMap(24);
-        var keys0 = headers.keys.toList();
-        var values0 = headers.values.toList();
+        var encoder1 = encoder0.encoderForMap(16);
+        var keys0 = lastSelectedAccounts.keys.toList();
+        var values0 = lastSelectedAccounts.values.toList();
         
         {
           var encoder2 = encoder1.encodePointerArray(keys0.length, bindings.ArrayDataHeader.kHeaderSize, bindings.kUnspecifiedArrayLength);
           for (int i1 = 0; i1 < keys0.length; ++i1) {
             encoder2.encodeString(keys0[i1], bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, false);
           }
         }
         
         {
           var encoder2 = encoder1.encodePointerArray(values0.length, bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize, bindings.kUnspecifiedArrayLength);
           for (int i1 = 0; i1 < values0.length; ++i1) {
             encoder2.encodeString(values0[i1], bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, false);
           }
         }
       }
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "headers of struct HttpRequest: $e";
-      rethrow;
-    }
-    try {
-      encoder0.encodeConsumerHandle(body, 32, true);
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "body of struct HttpRequest: $e";
+          "lastSelectedAccounts of struct Db: $e";
       rethrow;
     }
   }
 
   String toString() {
-    return "HttpRequest("
-           "relativeUrl: $relativeUrl" ", "
-           "method: $method" ", "
-           "headers: $headers" ", "
-           "body: $body" ")";
+    return "Db("
+           "version: $version" ", "
+           "lastSelectedAccounts: $lastSelectedAccounts" ")";
   }
 
   Map toJson() {
-    throw new bindings.MojoCodecError(
-        'Object containing handles cannot be encoded to JSON.');
+    Map map = new Map();
+    map["version"] = version;
+    map["lastSelectedAccounts"] = lastSelectedAccounts;
+    return map;
   }
 }