@@ -60,9 +60,10 @@ func normalizeDest(workingDir, requested string) (string, error) {

 func containsWildcards(name string) bool {

 	for i := 0; i < len(name); i++ {

 		ch := name[i]

-		if ch == '\\' {

+		switch ch {

+		case '\\':

 			i++

-		} else if ch == '*' || ch == '?' || ch == '[' {

+		case '*', '?', '[':

 			return true

 		}

 	}

@@ -556,9 +556,10 @@ func (r *controller) Logs(ctx context.Context, publisher exec.LogPublisher, opti

 			return errors.Wrap(err, "failed to convert timestamp")

 		}

 		var stream api.LogStream

-		if msg.Source == "stdout" {

+		switch msg.Source {

+		case "stdout":

 			stream = api.LogStreamStdout

-		} else if msg.Source == "stderr" {

+		case "stderr":

 			stream = api.LogStreamStderr

 		}

@@ -188,7 +188,8 @@ func (p *pullProgress) UpdateProgress(ctx context.Context, ongoing *jobs, out pr

 			return err

 		}

-		if sn.Kind == snapshots.KindActive {

+		switch sn.Kind {

+		case snapshots.KindActive:

 			if p.unpackStart == nil {

 				p.unpackStart = make(map[digest.Digest]time.Time)

 			}

@@ -209,7 +210,7 @@ func (p *pullProgress) UpdateProgress(ctx context.Context, ongoing *jobs, out pr

 					Current: 1 + seconds,

 					Units:   "s",

 				})

-		} else if sn.Kind == snapshots.KindCommitted {

+		case snapshots.KindCommitted:

 			out.WriteProgress(progress.Progress{

 				ID:         stringid.TruncateID(desc.Digest.Encoded()),

 				Action:     "Pull complete",

@@ -85,16 +85,19 @@ func New(info logger.Info) (logger.Logger, error) {

 	}

 	var gelfWriter gelf.Writer

-	if address.Scheme == "udp" {

+	switch address.Scheme {

+	case "udp":

 		gelfWriter, err = newGELFUDPWriter(address.Host, info)

 		if err != nil {

 			return nil, err

 		}

-	} else if address.Scheme == "tcp" {

+	case "tcp":

 		gelfWriter, err = newGELFTCPWriter(address.Host, info)

 		if err != nil {

 			return nil, err

 		}

+	default:

+		// TODO: consider returning an error for other schemes

 	}

 	return &gelfLogger{

@@ -421,9 +421,10 @@ func (tr Reader) TestConcurrent(t *testing.T) {

 	stderrMessages := []*logger.Message{}

 	stdoutMessages := []*logger.Message{}

 	for _, m := range makeTestMessages() {

-		if m.Source == "stdout" {

+		switch m.Source {

+		case "stdout":

 			stdoutMessages = append(stdoutMessages, m)

-		} else if m.Source == "stderr" {

+		case "stderr":

 			stderrMessages = append(stderrMessages, m)

 		}

 	}

@@ -468,11 +469,12 @@ func (tr Reader) TestConcurrent(t *testing.T) {

 		}

 		var messages *[]*logger.Message

-		if l.Source == "stdout" {

+		switch l.Source {

+		case "stdout":

 			messages = &stdoutMessages

-		} else if l.Source == "stderr" {

+		case "stderr":

 			messages = &stderrMessages

-		} else {

+		default:

 			t.Fatalf("Corrupted message.Source = %q", l.Source)

 		}

@@ -426,10 +426,13 @@ func (daemon *Daemon) createNetwork(ctx context.Context, cfg *config.Config, cre

 func (daemon *Daemon) pluginRefCount(driver, capability string, mode int) {

 	var builtinDrivers []string

-	if capability == driverapi.NetworkPluginEndpointType {

+	switch capability {

+	case driverapi.NetworkPluginEndpointType:

 		builtinDrivers = daemon.netController.BuiltinDrivers()

-	} else if capability == ipamapi.PluginEndpointType {

+	case ipamapi.PluginEndpointType:

 		builtinDrivers = daemon.netController.BuiltinIPAMDrivers()

+	default:

+		// other capabilities can be ignored for now

 	}

 	for _, d := range builtinDrivers {

@@ -518,7 +518,8 @@ func pushReservation(bytePos, bitPos uint64, head *sequence, release bool) (_ *s

 	newSequence := &sequence{block: newBlock, count: 1}

 	// Insert the new sequence in the list based on block position

-	if precBlocks == 0 { // First in sequence (A)

+	switch precBlocks {

+	case 0: // First in sequence (A)

 		newSequence.next = current

 		if current == head {

 			newHead = newSequence

@@ -528,11 +529,11 @@ func pushReservation(bytePos, bitPos uint64, head *sequence, release bool) (_ *s

 		}

 		removeCurrentIfEmpty(&newHead, newSequence, current)

 		mergeSequences(previous)

-	} else if precBlocks == current.count { // Last in sequence (B)

+	case current.count: // Last in sequence (B)

 		newSequence.next = current.next

 		current.next = newSequence

 		mergeSequences(current)

-	} else { // In between the sequence (C)

+	default: // In between the sequence (C)

 		currPre := &sequence{block: current.block, count: precBlocks, next: newSequence}

 		currPost := current

 		currPost.count -= precBlocks