Interface update, per-method Contexts.

impl/memory/mail.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "fmt"
         net_mail "net/mail"
         "net/textproto"
         "path/filepath"
         "strings"
         "sync"
 
         "github.com/luci/gae/service/mail"
         "github.com/luci/gae/service/user"
         "golang.org/x/net/context"
 )
 
 type mailData struct {
         sync.Mutex
         queue       []*mail.TestMessage
         admins      []string
         adminsPlain []string
 }
 
 // mailImpl is a contextual pointer to the current mailData.
 type mailImpl struct {
+        context.Context
+
         data *mailData
-
-        c context.Context
 }
 
-var _ mail.Interface = (*mailImpl)(nil)
+var _ mail.RawInterface = (*mailImpl)(nil)
 
-// useMail adds a mail.Interface implementation to context, accessible
-// by mail.Get(c)
+// useMail adds a mail.RawInterface implementation to context, accessible
+// by mail.Raw(c) or the exported mail methods.
 func useMail(c context.Context) context.Context {
         data := &mailData{
                 admins:      []string{"admin@example.com"},
                 adminsPlain: []string{"admin@example.com"},
         }
 
-        return mail.SetFactory(c, func(c context.Context) mail.Interface {
-                return &mailImpl{data, c}
+        return mail.SetFactory(c, func(ic context.Context) mail.RawInterface {
+                return &mailImpl{ic, data}
         })
 }
 
 func parseEmails(emails ...string) error {
         for _, e := range emails {
                 if _, err := net_mail.ParseAddress(e); err != nil {
                         return fmt.Errorf("invalid email (%q): %s", e, err)
                 }
         }
         return nil
@@ skipping 65 matching lines @@
                 vals := msg.Headers[k]
                 delete(msg.Headers, k)
                 msg.Headers[canonK] = vals
         }
 
         return nil
 }
 
 func (m *mailImpl) sendImpl(msg *mail.Message) error {
         email := ""
-        userSvc := user.Get(m.c)
-        if u := userSvc.Current(); u != nil {
+        if u := user.Current(m); u != nil {
                 email = u.Email
         }
 
         m.data.Lock()
         adminsPlain := m.data.adminsPlain[:]
         m.data.Unlock()
 
         testMsg := &mail.TestMessage{Message: *msg}
 
         if err := checkMessage(testMsg, adminsPlain, email); err != nil {
@@ skipping 14 matching lines @@
         m.data.Lock()
         ads := m.data.admins[:]
         m.data.Unlock()
 
         msg.To = make([]string, len(ads))
         copy(msg.To, ads)
 
         return m.sendImpl(msg)
 }
 
-func (m *mailImpl) Testable() mail.Testable {
-        return m
-}
+func (m *mailImpl) GetTestable() mail.Testable { return m }
 
 func (m *mailImpl) SetAdminEmails(emails ...string) {
         adminsPlain := make([]string, len(emails))
         for i, e := range emails {
                 adr, err := net_mail.ParseAddress(e)
                 if err != nil {
                         panic(fmt.Errorf("invalid email (%q): %s", e, err))
                 }
                 adminsPlain[i] = adr.Address
         }
@@ skipping 14 matching lines @@
                 ret[i] = m.Copy()
         }
         return ret
 }
 
 func (m *mailImpl) Reset() {
         m.data.Lock()
         m.data.queue = nil
         m.data.Unlock()
 }